desjs演算法

① 求教des演算法的詳細過程

des演算法的詳細過程：
1-1、變換密鑰
取得64位的密鑰，每個第8位作為奇偶校驗位。
1-2、變換密鑰。
1-2-1、舍棄64位密鑰中的奇偶校驗位，根據下表（PC-1）進行密鑰變換得到56位的密鑰，在變換中，奇偶校驗位以被舍棄。
Permuted Choice 1 (PC-1)
57 49 41 33 25 17 9
1 58 50 42 34 26 18
10 2 59 51 43 35 27
19 11 3 60 52 44 36
63 55 47 39 31 23 15
7 62 54 46 38 30 22
14 6 61 53 45 37 29
21 13 5 28 20 12 4
1-2-2、將變換後的密鑰分為兩個部分，開始的28位稱為C[0]，最後的28位稱為D[0]。
1-2-3、生成16個子密鑰，初始I=1。
1-2-3-1、同時將C[I]、D[I]左移1位或2位，根據I值決定左移的位數。見下表
I： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
左移位數： 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1
1-2-3-2、將C[I]D[I]作為一個整體按下表（PC-2）變換，得到48位的K[I]
Permuted Choice 2 (PC-2)
14 17 11 24 1 5
3 28 15 6 21 10
23 19 12 4 26 8
16 7 27 20 13 2
41 52 31 37 47 55
30 40 51 45 33 48
44 49 39 56 34 53
46 42 50 36 29 32
1-2-3-3、從1-2-3-1處循環執行，直到K[16]被計算完成。
2、處理64位的數據
2-1、取得64位的數據，如果數據長度不足64位，應該將其擴展為64位（例如補零）
2-2、將64位數據按下表變換（IP）
Initial Permutation (IP)
58 50 42 34 26 18 10 2
60 52 44 36 28 20 12 4
62 54 46 38 30 22 14 6
64 56 48 40 32 24 16 8
57 49 41 33 25 17 9 1
59 51 43 35 27 19 11 3
61 53 45 37 29 21 13 5
63 55 47 39 31 23 15 7
2-3、將變換後的數據分為兩部分，開始的32位稱為L[0]，最後的32位稱為R[0]。
2-4、用16個子密鑰加密數據，初始I=1。
2-4-1、將32位的R[I-1]按下表（E）擴展為48位的E[I-1]
Expansion (E)
32 1 2 3 4 5
4 5 6 7 8 9
8 9 10 11 12 13
12 13 14 15 16 17
16 17 18 19 20 21
20 21 22 23 24 25
24 25 26 27 28 29
28 29 30 31 32 1
2-4-2、異或E[I-1]和K[I]，即E[I-1] XOR K[I]
2-4-3、將異或後的結果分為8個6位長的部分，第1位到第6位稱為B[1]，第7位到第12位稱為B[2]，依此類推，第43位到第48位稱為B[8]。
2-4-4、按S表變換所有的B[J]，初始J=1。所有在S表的值都被當作4位長度處理。
2-4-4-1、將B[J]的第1位和第6位組合為一個2位長度的變數M，M作為在S[J]中的行號。
2-4-4-2、將B[J]的第2位到第5位組合，作為一個4位長度的變數N，N作為在S[J]中的列號。
2-4-4-3、用S[J][M][N]來取代B[J]。
Substitution Box 1 (S[1])
14 4 13 1 2 15 11 8 3 10 6 12 5 9 0 7
0 15 7 4 14 2 13 1 10 6 12 11 9 5 3 8
4 1 14 8 13 6 2 11 15 12 9 7 3 10 5 0
15 12 8 2 4 9 1 7 5 11 3 14 10 0 6 13
S[2]
15 1 8 14 6 11 3 4 9 7 2 13 12 0 5 10
3 13 4 7 15 2 8 14 12 0 1 10 6 9 11 5
0 14 7 11 10 4 13 1 5 8 12 6 9 3 2 15
13 8 10 1 3 15 4 2 11 6 7 12 0 5 14 9
S[3]
10 0 9 14 6 3 15 5 1 13 12 7 11 4 2 8
13 7 0 9 3 4 6 10 2 8 5 14 12 11 15 1
13 6 4 9 8 15 3 0 11 1 2 12 5 10 14 7
1 10 13 0 6 9 8 7 4 15 14 3 11 5 2 12
S[4]
7 13 14 3 0 6 9 10 1 2 8 5 11 12 4 15
13 8 11 5 6 15 0 3 4 7 2 12 1 10 14 9
10 6 9 0 12 11 7 13 15 1 3 14 5 2 8 4
3 15 0 6 10 1 13 8 9 4 5 11 12 7 2 14
S[5]
2 12 4 1 7 10 11 6 8 5 3 15 13 0 14 9
14 11 2 12 4 7 13 1 5 0 15 10 3 9 8 6
4 2 1 11 10 13 7 8 15 9 12 5 6 3 0 14
11 8 12 7 1 14 2 13 6 15 0 9 10 4 5 3
S[6]
12 1 10 15 9 2 6 8 0 13 3 4 14 7 5 11
10 15 4 2 7 12 9 5 6 1 13 14 0 11 3 8
9 14 15 5 2 8 12 3 7 0 4 10 1 13 11 6
4 3 2 12 9 5 15 10 11 14 1 7 6 0 8 13
S[7]
4 11 2 14 15 0 8 13 3 12 9 7 5 10 6 1
13 0 11 7 4 9 1 10 14 3 5 12 2 15 8 6
1 4 11 13 12 3 7 14 10 15 6 8 0 5 9 2
6 11 13 8 1 4 10 7 9 5 0 15 14 2 3 12
S[8]
13 2 8 4 6 15 11 1 10 9 3 14 5 0 12 7
1 15 13 8 10 3 7 4 12 5 6 11 0 14 9 2
7 11 4 1 9 12 14 2 0 6 10 13 15 3 5 8
2 1 14 7 4 10 8 13 15 12 9 0 3 5 6 11
2-4-4-4、從2-4-4-1處循環執行，直到B[8]被替代完成。
2-4-4-5、將B[1]到B[8]組合，按下表（P）變換，得到P。
Permutation P
16 7 20 21
29 12 28 17
1 15 23 26
5 18 31 10
2 8 24 14
32 27 3 9
19 13 30 6
22 11 4 25
2-4-6、異或P和L[I-1]結果放在R[I]，即R[I]=P XOR L[I-1]。
2-4-7、L[I]=R[I-1]
2-4-8、從2-4-1處開始循環執行，直到K[16]被變換完成。
2-4-5、組合變換後的R[16]L[16]（注意：R作為開始的32位），按下表（IP-1）變換得到最後的結果。
Final Permutation (IP**-1)
40 8 48 16 56 24 64 32
39 7 47 15 55 23 63 31
38 6 46 14 54 22 62 30
37 5 45 13 53 21 61 29
36 4 44 12 52 20 60 28
35 3 43 11 51 19 59 27
34 2 42 10 50 18 58 26
33 1 41 9 49 17 57 25
以上就是DES演算法的描述。

② 「DES」和「AES」演算法的比較，各自優缺點有哪些

DES演算法優點：DES演算法具有極高安全性，到目前為止，除了用窮舉搜索法對DES演算法進行攻擊外，還沒有發現更有效的辦法。

DES演算法缺點：

1、分組比較短。

2、密鑰太短。

3、密碼生命周期短。

4、運算速度較慢。

AES演算法優點：

1、運算速度快。

2、對內存的需求非常低，適合於受限環境。

3、分組長度和密鑰長度設計靈活。

4、 AES標准支持可變分組長度，分組長度可設定為32比特的任意倍數，最小值為128比特，最大值為256比特。

5、 AES的密鑰長度比DES大，它也可設定為32比特的任意倍數，最小值為128比特，最大值為256比特，所以用窮舉法是不可能破解的。

6、很好的抵抗差分密碼分析及線性密碼分析的能力。

AES演算法缺點：目前尚未存在對AES 演算法完整版的成功攻擊，但已經提出對其簡化演算法的攻擊。

(2)desjs演算法擴展閱讀：

高級加密標准（英語：Advanced Encryption Standard，縮寫：AES），在密碼學中又稱Rijndael加密法，是美國聯邦政府採用的一種區塊加密標准。

這個標准用來替代原先的DES，已經被多方分析且廣為全世界所使用。經過五年的甄選流程，高級加密標准由美國國家標准與技術研究院（NIST）於2001年11月26日發布於FIPS PUB 197，並在2002年5月26日成為有效的標准。2006年，高級加密標准已然成為對稱密鑰加密中最流行的演算法之一。

③ 對稱加密演算法之DES介紹

DES (Data Encryption Standard)是分組對稱密碼演算法。

DES演算法利用 多次組合替代演算法 和 換位演算法 ，分散和錯亂的相互作用，把明文編製成密碼強度很高的密文，它的加密和解密用的是同一演算法。

DES演算法，是一種 乘積密碼 ，其在演算法結構上主要採用了 置換 、 代替 、 模二相加 等函數，通過 輪函數 迭代的方式來進行計算和工作。

DES演算法也會使用到數據置換技術，主要有初始置換 IP 和逆初始置換 IP^-1 兩種類型。DES演算法使用置換運算的目的是將原始明文的所有格式及所有數據全部打亂重排。而在輪加密函數中，即將數據全部打亂重排，同時在數據格式方面，將原有的32位數據格式，擴展成為48位數據格式，目的是為了滿足S盒組對數據長度和數據格式規范的要求。

一組數據信息經過一系列的非線性變換以後，很難從中推導出其計算的過程和使用的非線性組合；但是如果這組數據信息使用的是線性變換，計算就容易的多。在DES演算法中，屬於非線性變換的計算過程只有S盒，其餘的數據計算和變換都是屬於線性變換，所以DES演算法安全的關鍵在於S盒的安全強度。此外，S盒和置換IP相互配合，形成了很強的抗差分攻擊和抗線性攻擊能力，其中抗差分攻擊能力更強一些。

DES演算法是一種分組加密機制，將明文分成N個組，然後對各個組進行加密，形成各自的密文，最後把所有的分組密文進行合並，形成最終的密文。

DES加密是對每個分組進行加密，所以輸入的參數為分組明文和密鑰，明文分組需要置換和迭代，密鑰也需要置換和循環移位。在初始置換IP中，根據一張8*8的置換表，將64位的明文打亂、打雜，從而提高加密的強度；再經過16次的迭代運算，在這些迭代運算中，要運用到子密鑰；每組形成的初始密文，再次經過初始逆置換 IP^-1 ，它是初始置換的逆運算，最後得到分組的最終密文。

圖2右半部分，給出了作用56比特密鑰的過程。DES演算法的加密密鑰是64比特，但是由於密鑰的第n*8(n=1,2…8)是校驗(保證含有奇數個1)，因此實際參與加密的的密鑰只有 56比特 。開始時，密鑰經過一個置換，然後經過循環左移和另一個置換分別得到子密鑰ki，供每一輪的迭代加密使用。每輪的置換函數都一樣，但是由於密鑰位的重復迭代使得子密鑰互不相同。

DES演算法 利用多次組合替代演算法和換位演算法，分散和錯亂的相互作用，把明文編製成密碼強度很高的密文，它的加密和解密用的是同一演算法。

DES演算法詳述：DES對64位明文分組(密鑰56bit)進行操作。

1、 初始置換函數IP：64位明文分組x經過一個初始置換函數IP，產生64位的輸出x0，再將分組x0分成左半部分L0和右半部分R0：即將輸入的第58位換到第一位，第50位換到第2位，…，依次類推，最後一位是原來的第7位。L0、R0則是換位輸出後的兩部分，L0是輸出的左32位，R0是右32位。例，設置換前的輸入值為D1D2D3…D64，則經過初始置換後的結果為：L0=D58D50…D8；R0=D57D49…D7.其置換規則如表1所示。

DES加密過程最後的逆置換 IP^-1 ，是表1的 逆過程 。就是把原來的每一位都恢復過去，即把第1位的數據，放回到第58位，把第2位的數據，放回到第50位。

2、 獲取子密鑰 Ki ：DES加密演算法的密鑰長度為56位，一般表示為64位(每個第8位用於奇偶校驗)，將用戶提供的64位初始密鑰經過一系列的處理得到K1,K2,…,K16，分別作為 1~16 輪運算的 16個子密鑰 。

(1). 將64位密鑰去掉8個校驗位，用密鑰置換 PC-1 (表2)置換剩下的56位密鑰；

(2). 將56位分成前28位C0和後28位D0，即 PC-1(K56)=C0D0 ;

(3). 根據輪數，這兩部分分別循環左移1位或2位，表3：

(4). 移動後，將兩部分合並成56位後通過壓縮置換PC-2(表4)後得到48位子密鑰，即Ki=PC-2(CiDi).

子密鑰產生如圖2所示：

3、 密碼函數F(非線性的)

(1). 函數F的操作步驟：密碼函數F 的輸入是32比特數據和48比特的子密鑰：
A．擴展置換(E):將數據的右半部分Ri從32位擴展為48位。位選擇函數(也稱E盒)，如表5所示：

B．異或：擴展後的48位輸出E(Ri)與壓縮後的48位密鑰Ki作異或運算；

C．S盒替代：將異或得到的48位結果分成八個6位的塊，每一塊通過對應的一個S盒產生一個4位的輸出。

(2)、D、P盒置換：將八個S盒的輸出連在一起生成一個32位的輸出，輸出結果再通過置換P產生一個32位的輸出即：F(Ri,Ki)，F(Ri,Ki)演算法描述如圖3，最後，將P盒置換的結果與最初的64位分組的左半部分異或，然後，左、右半部分交換，開始下一輪計算。

4、密文輸出：經過16次迭代運算後，得到L16、R16，將此作為輸入，進行逆置換，即得到密文輸出。逆置換正好是初始置的逆運算。例如，第1位經過初始置換後，處於第40位，而通過逆置換，又將第40位換回到第1位，其逆置換規則如表8所示：

圖4為DES演算法加密原理圖：

DES演算法加密和解密過程採用相同的演算法，並採用相同的加密密鑰和解密密鑰，兩者的區別是：(1)、DES加密是從L0、R0到L15、R15進行變換，而解密時是從L15、R15到L0、R0進行變換的；(2)、加密時各輪的加密密鑰為K0K1…K15，而解密時各輪的解密密鑰為K15K14…K0；(3)、加密時密鑰循環左移，解密時密鑰循環右移。

DES加密過程分析：

(1)、首先要生成64位密鑰，這64位的密鑰經過「子密鑰演算法」換轉後，將得到總共16個子密鑰。將這些子密鑰標識為Kn(n=1,2,…,16)。這些子密鑰主要用於總共十六次的加密迭代過程中的加密工具。

(2)、其次要將明文信息按64位數據格式為一組，對所有明文信息進行分組處理。每一段的64位明文都要經過初試置換IP，置換的目的是將數據信息全部打亂重排。然後將打亂的數據分為左右兩塊，左邊一塊共32位為一組，標識為L0；右邊一塊也是32位為一組，標識為R0.

(3)、置換後的數據塊總共要進行總共十六次的加密迭代過程。加密迭代主要由加密函數f來實現。首先使用子密鑰K1對右邊32位的R0進行加密處理，得到的結果也是32位的；然後再將這個32位的結果數據與左邊32位的L0進行模2處理，從而再次得到一個32位的數據組。我們將最終得到的這個32位組數據，作為第二次加密迭代的L1，往後的每一次迭代過程都與上述過程相同。

(4)、在結束了最後一輪加密迭代之後，會產生一個64位的數據信息組，然後我們將這個64位數據信息組按原有的數據排列順序平均分為左右兩等分，然後將左右兩等分的部分進行位置調換，即原來左等分的數據整體位移至右側，而原來右等分的數據則整體位移至左側，這樣經過合並後的數據將再次經過逆初始置換IP^-1的計算，我們最終將得到一組64位的密文。

DES解密過程分析：DES的解密過程與它的加密過程是一樣的，這是由於DES演算法本身屬於對稱密碼體制演算法，其加密和解密的過程可以共用同一個過程和運算。

DES加密函數f：在DES演算法中，要將64位的明文順利加密輸出成64位的密文，而完成這項任務的核心部分就是加密函數f。加密函數f的主要作用是在第m次的加密迭代中使用子密鑰Km對Km-1進行加密操作。加密函數f在加密過程中總共需要運行16輪。

十六輪迭代演算法：它先將經過置換後的明文分成兩組，每組32位；同時密鑰也被分成了兩組，每組28位，兩組密鑰經過運算，再聯合成一個48位的密鑰，參與到明文加密的運算當中。S盒子，它由8個4*16的矩陣構成，每一行放著0到15的數據，順序各個不同，是由IBM公司設計好的。經過異或運算的明文，是一個48位的數據，在送入到S盒子的時候，被分成了8份，每份6位，每一份經過一個S盒子，經過運算後輸出為4位，即是一個0到15的數字的二進製表示形式。具體運算過程為，將輸入的6位中的第1位為第6位合並成一個二進制數，表示行號，其餘4位也合並成一個二進制數，表示列號。在當前S盒子中，以這個行號和列號為准，取出相應的數，並以二進制的形式表示，輸出，即得到4位的輸出，8個S盒子共計32位。

DES演算法優缺點：

(1)、產生密鑰簡單，但密鑰必須高度保密，因而難以做到一次一密；

(2)、DES的安全性依賴於密鑰的保密。攻擊破解DES演算法的一個主要方法是通過密鑰搜索，使用運算速度非常高的計算機通過排列組合枚舉的方式不斷嘗試各種可能的密鑰，直到破解為止。一般，DES演算法使用56位長的密鑰，通過簡單計算可知所有可能的密鑰數量最多是2^56個。隨著巨型計算機運算速度的不斷提高，DES演算法的安全性也將隨之下降，然而在一般的民用商業場合，DES的安全性仍是足夠可信賴的。

(3)、DES演算法加密解密速度比較快，密鑰比較短，加密效率很高但通信雙方都要保持密鑰的秘密性，為了安全還需要經常更換DES密鑰。

參考鏈接 ： https://blog.csdn.net/fengbingchun/article/details/42273257

④ 推導DES加密演算法原理

密碼體制從原理上可分為2大類，即單鑰密碼體制和雙鑰密碼體制。
單鑰密碼體制是指信息的發送方和接受方共享一把鑰匙。在現代網路通信條件下，該 體制的一個關鍵問題是如何將密鑰安全可靠地分配給通信的對方，並進行密鑰管理。因此單 鑰密碼體制在實際應用中除了要設計出滿足安全性要求的加密演算法外，還必須解決好密碼的 產生、分配、傳輸、存儲和銷毀等多方面問題。單鑰密碼可分為古典密碼、流密碼和分組密 碼，DES就屬於分組密碼中的一種。
雙鑰密碼體制又稱公鑰密碼體制，其最大特點是採用2個密鑰將加密、解密分開。在 雙鑰體制下，每個用戶都擁有2把密鑰，—個公開，一個自己專用。當使用用戶專用密鑰加 密，而用該用戶公開密鑰解密時，則可實現一個被加密的消息能被多個用戶解讀；當使用 用戶公開密鑰加密，而用該用戶專用密鑰解密時，則可實現傳輸的信息只被一個用戶解讀。 前者常被用於數字簽名，後者常被用於保密通信。
DES演算法詳述
DES演算法把64位的明文輸入塊變為64位的密文輸出塊，他所使用的密鑰也是64位，DES對64 位的明文分組進行操作。通過一個初始置換，將明文分組分成左半部分和右半部分，各32位 長。然後進行16輪相同的運算，這些相同的運算被稱為函數f，在運算過程中數據和密 鑰相結合。經過16輪運算後左、右部分在一起經過一個置換（初始置換的逆置換），這樣算 法就完成了。

⑤ （高分）javascript實現des加密

搞定，已經可以了

<html>
<head>
<meta http-equiv="content-type" content="text/html;charset=gb2312">
<title>DES演算法-Code by 梅雪香</title>
<style type="text/css">
textarea{width:600px; height:150px;}
body{font-size:12px}
input{font-size:12px}
</style>
<script language="JavaScript">
<!--
var DES = {
// initial permutation IP
IP_Table : [
58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8,
57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3,
61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7
],
// final permutation IP^-1
IPR_Table : [
40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31,
38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29,
36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27,
34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25
],
// permuted choice table (key)
PC1_Table : [
57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4
],
// permuted choice key (table)
PC2_Table : [
14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
],
// number left rotations of pc1
LOOP_Table : [1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1],
// expansion operation matrix
E_Table : [
32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9,
8, 9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17,
16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25,
24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32, 1
],
// 32-bit permutation function P used on the output of the S-boxes
P_Table : [ 16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10,
2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25 ],

// The (in)famous S-boxes
S_Box : [
// S1
[[14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7],
[ 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8],
[ 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0],
[15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13]],
// S2
[[15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10],
[ 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5],
[ 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15],
[13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9]],
// S3
[[10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8],
[13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1],
[13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7],
[ 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12]],
// S4
[[ 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15],
[13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9],
[10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4],
[ 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14]],
// S5
[[ 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9],
[14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6],
[ 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14],
[11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3]],
// S6
[[12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11],
[10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8],
[ 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6],
[ 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13]],
// S7
[[ 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1],
[13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6],
[ 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2],
[ 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12]],
// S8
[[13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7],
[ 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2],
[ 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8],
[ 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11]]
],
Oct2Bin : ["0000","0001","0010","0011","0100","0101","0110","0111",
"1000","1001","1010","1011","1100","1101","1110","1111" ],
//str 為八位的字元
subKeys : new Array(16),
key : "",
text : ""
};

DES.init = function(key,text){
if(key != this.key){
this.key=key;
this.GenSubKey();
}
this.text= text + " ".substring(0,parseInt("07654321".charAt( text.length%8 ),10));
};

DES.GenSubKey = function(){
var arr = this.Permute( this.Byte2Bit(this.key) , this.PC1_Table);
var AL = arr.slice(0,28);
var AR = arr.slice(28,56);
for(var i=0; i<16; i++) {
for(var j=0,k=this.LOOP_Table[i];j<k;j++){
AL.push(AL.shift());
AR.push(AR.shift());
}
this.subKeys[i] = this.Permute( AL.concat(AR) , this.PC2_Table );
}
};
//數組ar存儲二進制數據,該函數將從頭開始的每八位轉換成對應的字元
DES.Bit2Byte = function(ar,fCh){
var str="";
if(fCh == "byte"){
var tmpAr = ar.join("").match(/.{8}/g);
for(var i=0,j=tmpAr.length; i<j; i++)
str += String.fromCharCode(parseInt(tmpAr[i],2));
}
else if(fCh == "hex"){
var tmpAr = ar.join("").match(/.{4}/g);
for(var i=0,j=tmpAr.length; i<j; i++)
str += "0123456789abcdef".charAt(parseInt(tmpAr[i],2));
}
else return "Error:Second param is wrong.";
return str;
};
//將字元串轉換成二進制數組
DES.Byte2Bit = function(str){
for(var i=0,j=8*str.length,ar = [],ch=""; i<j; i++){
var k = 7 - i%8;
if(k == 7) ch = str.charCodeAt(parseInt(i/8,10));
ar.push( (ch >> k) & 1 );
}
return ar;
};

//將16進制字元串轉變成二進制數組
DES.Hex2Bin = function(str){
for(var i=0,j=str.length,s=""; i<j; i++)
s += this.Oct2Bin[ parseInt(str.charAt(i),16)];
return s.split("");
};

DES.Xor = function(A,B){
for(var i=0,j=B.length,rtn=new Array(j); i<j; i++)
rtn[i] = A[i] ^ B[i];
return rtn;
}

DES.Permute = function(ar,tb){
for(var i=0,j=tb.length,rtn=new Array(j);i<j;i++)
rtn[i] = ar[tb[i]-1];
return rtn;
};

DES.F_func = function(Ri,Ki)
{
return this.Permute( this.S_func( this.Xor( this.Permute( Ri , this.E_Table ) , Ki) ) , this.P_Table);
};
//ar為輸入48位串數組
DES.S_func = function(ar){
for(var i=0,arRtn = [];i<8;i++){
var x = i*6;
var j = parseInt(""+ar[x]+ar[x+5],2);
var k = parseInt(ar.slice(x+1,x+5).join(""),2);
arRtn = arRtn.concat( this.Oct2Bin[ this.S_Box[i][j][k] ].split("") );
}
return arRtn;
}

//mode參數為處理模式."Encrypt":加密 "Decrypt":解密,默認為加密
DES.Encrypt = function(mode){
mode = mode?mode:"Encrypt";
if(mode=="Decrypt")
var plainTextAr = this.Hex2Bin(this.text).join("").match(/.{64}/g);
else
var plainTextAr = this.Byte2Bit(this.text).join("").match(/.{64}/g);
for(var i=0,j=plainTextAr.length;i<j;i++){
var arr = this.Permute(plainTextAr[i].split(""),this.IP_Table)
var AL = arr.slice(0,32);
var AR = arr.slice(32,64);
if(mode == "Decrypt"){
for(var k=15;k>-1;k--){
var tmp = AR.slice(0,32);
AR = this.Xor(this.F_func(AR,this.subKeys[k]) , AL);
AL = tmp;
}
}
else{
for(var k=0;k<16;k++){
var tmp = AR.slice(0,32);
AR = this.Xor(this.F_func(AR,this.subKeys[k]) , AL);
AL = tmp;
}
}
plainTextAr[i] = this.Bit2Byte(this.Permute(AR.concat(AL), this.IPR_Table),(mode=="Decrypt"?"byte":"hex"));
}
return plainTextAr.join("").trim();
}
String.prototype.trim = function(){ return this.replace(/\s+$/g,"");}
//-->
</script>

<script language="JavaScript">
<!--
var $ = document.getElementById;
function jiami(){
DES.init($("txtKey").value,encodeURI($("taText").value) );
$("taCipher").value = DES.Encrypt();
}
function jiemi(){
DES.init($("txtKey").value,$("taCipher").value );
$("taText").value =decodeURI(DES.Encrypt("Decrypt"));
}
//-->
</script>
</head>

<body>
請輸入加(解)密密鑰:<input id="txtKey" type="text" onfocus="this.select()" value="47944980" size="10">
<font color="red">(*目前密鑰只能是八位)</font><br>

未加密文本:<br>
<textarea id="taText">Hi,I'm meixuexiang.</textarea>
<input type="button" value="clear" onclick="document.all[this.sourceIndex-1].value=''"><br>
<input type="button" value="Encrypt" onclick="jiami()">
<input type="button" value="Decrypt" onclick="jiemi()"><br><br>
加密後文本:<br>
<textarea id="taCipher"></textarea>
<input type="button" value="clear" onclick="document.all[this.sourceIndex-1].value=''"><br>
<p>code by meixx(<a href="http://www.blogjava.net/mxx">梅雪香</a>) 2006-10-18 23:00 <a href="mailto:[email protected]">信息反饋</a></p>
</body>
</html>

⑥ des是什麼演算法

DES演算法為密碼體制中的對稱密碼體制，又被稱為美國數據加密標准，是1972年美國IBM公司研製的對稱密碼體制加密演算法。明文按64位進行分組，密鑰長64位，密鑰事實上是56位參與DES運算(第8、16、24、32、40、48、56、64位是校驗位，使得每個密鑰都有奇數個1)分組後的明文組和56位的密鑰按位替代或交換的方法形成密文組的加密方法。
其入口參數有三個:key、data、mode。key為加密解密使用的密鑰，data為加密解密的數據，mode為其工作模式。當模式為加密模式時，明文按照64位進行分組，形成明文組，key用於對數據加密，當模式為解密模式時，key用於對數據解密。實際運用中，密鑰只用到了64位中的56位，這樣才具有高的安全性。

⑦ js中常見的數據加密與解密的方法

加密在我們前端的開發中也是經常遇見的。本文只把我們常用的加密方法進行總結。不去糾結加密的具體實現方式（密碼學，太龐大了）。

常見的加密演算法基本分為這幾類，

RSA加密：RSA加密演算法是一種非對稱加密演算法。在公開密鑰加密和電子商業中RSA被廣泛使用。（這才是正經的加密演算法）

非對稱加密演算法：非對稱加密演算法需要兩個密鑰：公開密鑰（publickey:簡稱公鑰）和私有密鑰（privatekey:簡稱私鑰）。公鑰與私鑰是一對，如果用公鑰對數據進行加密，只有用對應的私鑰才能解密。因為加密和解密使用的是兩個不同的密鑰，所以這種演算法叫作非對稱加密演算法。

DES全稱為Data Encryption Standard，即數據加密標准，是一種使用密鑰加密的塊演算法

DES演算法的入口參數有三個：Key、Data、Mode。其中Key為7個位元組共56位，是DES演算法的工作密鑰；Data為8個位元組64位，是要被加密或被解密的數據；Mode為DES的工作方式,有兩種:加密或解密。

AES這個標准用來替代原先的DES

DES/AES我們合並在一起介紹其用法和特點

Base64是一種用64個字元來表示任意二進制數據的方法。base64是一種編碼方式而不是加密演算法。只是看上去像是加密而已（嚇唬人）。

⑧ DES和AES演算法的比較，各自優缺點有哪些

一、數據加密標准不同

1、DES演算法的入口參數有三個：Key、Data、Mode。

其中Key為7個位元組共56位，是DES演算法的工作密鑰；Data為8個位元組64位，是要被加密或被解密的數據；Mode為DES的工作方式,有兩種:加密或解密。

2、AES的基本要求是，採用對稱分組密碼體制，密鑰的長度最少支持為128、192、256，分組長度128位，演算法應易於各種硬體和軟體實現。

因此AES的密鑰長度比DES大， 它也可設定為32比特的任意倍數，最小值為128比特，最大值為256 比特，所以用窮舉法是不可能破解的。

二、運行速度不同

1、作為分組密碼，DES的加密單位僅有64位二進制，這對於數據傳輸來說太小，因為每個分組僅含8個字元，而且其中某些位還要用於奇偶校驗或其他通訊開銷。處理速度慢、加密耗時

2、AES對內存的需求非常低，運算速度快，在有反饋模式、無反饋模式的軟硬體中，Rijndael都表現出非常好的性能。

三、適用范圍不同

1、數據加密標准，速度較快，適用於加密大量數據的場合。DES在安全上是脆弱的，但由於快速DES晶元的大量生產，使得DES仍能暫時繼續使用，為提高安全強度，通常使用獨立密鑰的三級DES

2、AES 適用於8位的小型單片機或者普通的32位微處理器,並且適合用專門的硬體實現，硬體實現能夠使其吞吐量（每秒可以到達的加密/解密bit數）達到十億量級。同樣，其也適用於RFID系統。

⑨ DES演算法實現

完成一個DES 演算法的 詳細設計 ,內容包括：

DES（Data Encryption Standard）是一種用於電子數據加密的對稱密鑰塊加密演算法 .它以64位為分組長度，64位一組的明文作為演算法的輸入，通過一系列復雜的操作，輸出同樣64位長度的密文。DES 同樣採用64位密鑰，但由於每8位中的最後1位用於奇偶校驗，實際有效密鑰長度為56位。密鑰可以是任意的56位的數，且可隨時改變。

DES 使用加密密鑰定義變換過程，因此演算法認為只有持有加密所用的密鑰的用戶才能解密密文。DES的兩個重要的安全特性是混淆和擴散。其中 混淆 是指通過密碼演算法使明文和密文以及密鑰的關系非常復雜，無法從數學上描述或者統計。 擴散 是指明文和密鑰中的每一位信息的變動，都會影響到密文中許多位信息的變動，從而隱藏統計上的特性，增加密碼的安全。

DES演算法的基本過程是換位和置換。如圖，有16個相同的處理階段，稱為輪。還有一個初始和最終的排列，稱為 IP 和 FP，它們是反向的 (IP 取消 FP 的作用，反之亦然)。

在主輪之前，塊被分成兩個32位的一半和交替處理；這種縱橫交錯的方案被稱為Feistel 方法。Feistel 結構確保了解密和加密是非常相似的過程——唯一的區別是在解密時子鍵的應用順序是相反的。其餘的演算法是相同的。這大大簡化了實現，特別是在硬體中，因為不需要單獨的加密和解密演算法。

符號表示異或（XOR）操作。Feistel 函數將半塊和一些鍵合在一起。然後，將Feistel 函數的輸出與塊的另一半組合在一起，在下一輪之前交換這一半。在最後一輪之後，兩隊交換了位置；這是 Feistel 結構的一個特性，使加密和解密過程類似。

IP 置換表指定64位塊上的輸入排列。其含義如下：輸出的第一個比特來自輸入的第58位;第二個位來自第50位，以此類推，最後一個位來自第7位輸入。

最後的排列是初始排列的倒數。

展開函數被解釋為初始排列和最終排列。注意，輸入的一些位在輸出時是重復的;輸入的第5位在輸出的第6位和第8位中都是重復的。因此，32位半塊被擴展到48位。

P排列打亂了32位半塊的位元。

表的「左」和「右」部分顯示了來自輸入鍵的哪些位構成了鍵調度狀態的左和右部分。輸入的64位中只有56位被選中；剩下的8（8、16、24、32、40、48、56、64）被指定作為奇偶校驗位使用。

這個排列從56位鍵調度狀態為每輪選擇48位的子鍵。

這個表列出了DES中使用的8個S-box，每個S-box用4位的輸出替換6位的輸入。給定一個6位輸入，通過使用外部的兩個位選擇行，以及使用內部的四個位選擇列，就可以找到4位輸出。例如，一個輸入「011011」有外部位「01」和內部位「1101」。第一行為「00」，第一列為「0000」，S-box S5對應的輸出為「1001」(=9)，即第二行第14列的值。

DES演算法的基本流程圖如下：

DES演算法是典型的對稱加密演算法，在輸入64比特明文數據後，通過輸入64比特密鑰和演算法的一系列加密步驟後，可以得到同樣為64比特的密文數據。反之，我們通過已知的密鑰，可以將密文數據轉換回明文。 我們將演算法分為了三大塊：IP置換、16次T迭代和IP逆置換 ，加密和解密過程分別如下：

實驗的設計模式是自頂向下的結構，用C語言去分別是先各個函數的功能，最後通過主函數將所有函數進行整合，讓演算法更加清晰客觀。

通過IP置換表，根據表中所示下標，找到相應位置進行置換。

對於16次 迭代，我們先將傳入的經過 IP 混淆過的64位明文的左右兩部分，分別為32位的 和32位的 。之後我們將 和 進行交換，得到作為IP逆置換的輸入：

，

子密鑰的生成，經歷下面一系列步驟：首先對於64位密鑰，進行置換選擇，因為將用戶輸入的64 位經歷壓縮變成了56位，所以我們將左面和右面的各28位進行循環位移。左右兩部分分別按下列規則做循環移位：當 ，循環左移1位；其餘情況循環左移2位。最後將得到的新的左右兩部分進行連接得到56位密鑰。

對半塊的 Feistel 操作分為以下五步：

如上二圖表明，在給出正確的密碼後，可以得到對應的明文。

若密碼錯誤，將解碼出錯誤答案。

【1】 Data Encryption Standard

【2】 DES演算法的詳細設計（簡單實現）

【3】 深入理解並實現DES演算法

【4】 DES演算法原理完整版

【5】 安全體系（一）—— DES演算法詳解