實現des演算法

① des加密演算法

des加密演算法如下：

一、DES加密演算法簡介

DES(Data Encryption Standard)是目前最為流行的加密演算法之一。DES是對稱的，也就是說它使用同一個密鑰來加密和解密數據。

DES還是一種分組加密演算法，該演算法每次處理固定長度的數據段，稱之為分組。DES分組的大小是64位，如果加密的數據長度不是64位的倍數，可以按照某種具體的規則來填充位。

從本質上來說，DES的安全性依賴於虛假表象，從密碼學的術語來講就是依賴於「混亂和擴散」的原則。混亂的目的是為隱藏任何明文同密文、或者密鑰之間的關系，而擴散的目的是使明文中的有效位和密鑰一起組成盡可能多的密文。兩者結合到一起就使得安全性變得相對較高。

DES演算法具體通過對明文進行一系列的排列和替換操作來將其加密。過程的關鍵就是從給定的初始密鑰中得到16個子密鑰的函數。要加密一組明文，每個子密鑰按照順序（1-16）以一系列的位操作施加於數據上，每個子密鑰一次，一共重復16次。每一次迭代稱之為一輪。要對密文進行解密可以採用同樣的步驟，只是子密鑰是按照逆向的順序（16-1）對密文進行處理。

② 什麼是DES演算法和什麼是RSA演算法其特點是什麼

分類: 電腦/網路
解析:

DES演算法全稱為Data Encryption Standard,即數據加密演算法,它是IBM公司於1975年研究成功並公開發表的。DES演算法的入口參數有三個:Key、Data、Mode。其中Key為8個位元組共64位,是DES演算法的工作密鑰;Data也為8個位元組64位,是要被加密或被解密的數據;Mode為DES的工作方式,有兩種:加密或解密。

DES演算法把64位的明文輸入塊變為64位的密文輸出塊,它所使用的密鑰也是64位，其演算法主要分為兩步：

1初始置換

其功能是把輸入的64位數據塊按位重新組合,並把輸出分為L0、R0兩部分,每部分各長3 2位,其置換規則為將輸入的第58位換到第一位,第50位換到第2位……依此類推,最後一位是原來的第7位。L0、R0則是換位輸出後的兩部分，L0是輸出的左32位,R0是右32位,例:設置換前的輸入值為D1D2D3……D64,則經過初始置換後的結果為:L0=D58D50……D8;R0=D57D49……D7。

2逆置換

經過16次迭代運算後,得到L16、R16,將此作為輸入,進行逆置換,逆置換正好是初始置換的逆運算，由此即得到密文輸出。

RSA演算法簡介

這種演算法1978年就出現了，它是第一個既能用於數據加密也能用於數字簽名的演算法。它易於理解和操作，也很流行。演算法的名字以發明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman。但RSA的安全性一直未能得到理論上的證明。

RSA的安全性依賴於大數分解。公鑰和私鑰都是兩個大素數（ 大於 100個十進制位）的函數。據猜測，從一個密鑰和密文推斷出明文的難度等同於分解兩個大素數的積。

密鑰對的產生。選擇兩個大素數，p 和q 。計算：

n = p * q

然後隨機選擇加密密鑰e，要求 e 和 ( p - 1 ) * ( q - 1 ) 互質。最後，利用Euclid 演算法計算解密密鑰d, 滿足

e * d = 1 ( mod ( p - 1 ) * ( q - 1 ) )

其中n和d也要互質。數e和n是公鑰，d是私拆核鑰。兩個素數p和q不再需要，應該丟棄，不要讓任何人知道。

加密信息 m（二進製表示）時，首先把m分成等長數據塊 m1 ,m2,..., mi ，塊長s，其中 2^s <= n, s 盡可能的大。對應的密文是：

ci = mi^e ( mod n ) ( a )

解密時作如下計算：

mi = ci^d ( mod n ) ( b )

RSA 可用於數字簽名，方案是用 ( a ) 式簽名， ( b )式驗證。具體操作時考慮到安全性和 m信息量較大等因素，一般是先作 HASH 運算。

RSA 的安全性。

RSA的安全性依賴於大數分解，但是否等同於大數分解一直未能得到理論上的證明，因為沒有證明破解RSA就一定蔽派需要作大數分解。假設存在一種無須分解大數的演算法，那它肯定可以修改成為大數分解演算法。目前， RSA的一些變種演算法已被證明等價於大數分解。不管怎樣，分解n是最顯然的攻擊方法。現在，人們已能分解140多個十進制位的大素數。因此，模數n必須選大一些，因具體適用情況而定。

RSA的速度。

由於進行的都是大數計算，使得RSA最快的情況也比DES慢上100倍，無論是軟體還是硬體實現。速度一直是RSA的缺陷。一般來說只用於少量數據加密。

RSA的選擇密文攻擊。

RSA在選擇密文攻擊面前很脆弱。一般攻擊者是將某一信息作一下偽裝(Blind)，讓擁有私鑰的實體簽署。然後，經過計算就可得到它所想要的信息。實際上，攻擊利用的都是同一個弱點，即存在這樣一個事實：乘冪保留了輸入的乘法結構：

( XM )^d = X^d *M^d mod n

前面已經提到，這個固有的問題來自於公鑰密碼系統的最有用的特徵--每個人都能使用公鑰。但從演算法上無法解決這一問題，主要措施有兩條：一條是采旅並掘用好的公鑰協議，保證工作過程中實體不對其他實體任意產生的信息解密，不對自己一無所知的信息簽名；另一條是決不對陌生人送來的隨機文檔簽名，簽名時首先使用One-Way Hash Function對文檔作HASH處理，或同時使用不同的簽名演算法。在中提到了幾種不同類型的攻擊方法。

RSA的公共模數攻擊。

若系統 *** 有一個模數，只是不同的人擁有不同的e和d，系統將是危險的。最普遍的情況是同一信息用不同的公鑰加密，這些公鑰共模而且互質，那末該信息無需私鑰就可得到恢復。設P為信息明文，兩個加密密鑰為e1和e2，公共模數是n，則：

C1 = P^e1 mod n

C2 = P^e2 mod n

密碼分析者知道n、e1、e2、C1和C2，就能得到P。

因為e1和e2互質，故用Euclidean演算法能找到r和s，滿足：

r * e1 + s * e2 = 1

假設r為負數，需再用Euclidean演算法計算C1^(-1)，則

( C1^(-1) )^(-r) * C2^s = P mod n

另外，還有其它幾種利用公共模數攻擊的方法。總之，如果知道給定模數的一對e和d，一是有利於攻擊者分解模數，一是有利於攻擊者計算出其它成對的e』和d』，而無需分解模數。解決辦法只有一個，那就是不要共享模數n。

RSA的小指數攻擊。 有一種提高RSA速度的建議是使公鑰e取較小的值，這樣會使加密變得易於實現，速度有所提高。但這樣作是不安全的，對付辦法就是e和d都取較大的值。

RSA演算法是第一個能同時用於加密和數字簽名的演算法，也易於理解和操作。 RSA是被研究得最廣泛的公鑰演算法，從提出到現在已近二十年，經歷了各種攻擊的考驗，逐漸為人們接受，普遍認為是目前最優秀的公鑰方案之一。RSA的安全性依賴於大數的因子分解，但並沒有從理論上證明破譯RSA的難度與大數分解難度等價。即RSA的重大缺陷是無法從理論上把握它的保密性能如何，而且密碼學界多數人士傾向於因子分解不是NPC問題。RSA的缺點主要有：A)產生密鑰很麻煩，受到素數產生技術的限制，因而難以做到一次一密。B)分組長度太大，為保證安全性，n 至少也要 600 bits以上，使運算代價很高，尤其是速度較慢，較對稱密碼演算法慢幾個數量級；且隨著大數分解技術的發展，這個長度還在增加，不利於數據格式的標准化。目前，SET(Secure Electronic Transaction)協議中要求CA採用2048比特長的密鑰，其他實體使用1024比特的密鑰。

③ DES 加密演算法解析

第一步是用密鑰初始化des

初始化的過程主要是用傳入的密鑰生成16對長度為48的Kn 子密鑰

生成48位子密鑰Kn的函數主要是 __create_sub_keys , 主要設計兩個換位表pc1和pc2

key = self.__permutate(des.__pc1, self.__String_to_BitList(self.getKey())) 開始先用換位表生成56位的初始key值（同pc1表的位數)

之後劃分成兩部分self.L和self.R各28位，然後是一個循環16此的左移操作，最後用pc2換位表生成第一個子密鑰Kn[0]

我們傳入數據調用encrypt函數即可， DES.encrypt('flag{isisisikey}') 我們先來看encrypt函數

encrypt函數主要調用了crypt函數，繼續跟進crypt函數，開始一部分是cbc模式獲取iv的過程，這里先暫時不考慮cbc,直接看關鍵部分

這里就設計到分組加密的核心了，為什麼DES又叫分組加密，有一操作是 block = self.__String_to_BitList(data[i:i+8]) 把加密數據每八個位元組分成一個block,然後調用 __String_to_BitList 會將八位元組字元轉換為64bit的二進制，每個block再調用 __des_crypt 函數加密

開始幾步和子密鑰生成函數類似，用一個ip換位表初始化block,然後劃分成self,L和self.R 各32位。

之後又是一個16輪的計算，我們分析一下每輪操作

self.R = self.__permutate(des.__expansion_table, self.R) 利用一個擴展表將32bit擴展成48位，擴展表:

B = [self.R[:6], self.R[6:12], self.R[12:18], self.R[18:24], self.R[24:30], self.R[30:36], self.R[36:42], self.R[42:]] 將48位的self.R 分成6*8為，之後一個循環就是經典的是s-box的置換操作

s-box盒一個八個，m是前後2bit,n是中間6bit, v是s-box的(n,m)處的值

self.R = self.__permutate(des.__p, Bn) 是P-box置換盒。 最後返回64bit的processed_block, 經過BitList_to_String函數處理就變成8位元組的字元流了，最後把每個block分組join一塊就是最後的密文。

我們再來總結一下這個過程

子密鑰生成演算法

des 加密演算法

附上完整版des加解密演算法腳本

④ des演算法加密解密的實現

本文介紹了一種國際上通用的加密演算法—DES演算法的原理，並給出了在VC++6.0語言環境下實現的源代碼。最後給出一個示例，以供參考。
關鍵字：DES演算法、明文、密文、密鑰、VC；

本文程序運行效果圖如下：

正文：
當今社會是信息化的社會。為了適應社會對計算機數據安全保密越來越高的要求，美國國家標准局(NBS)於1997年公布了一個由IBM公司研製的一種加密演算法，並且確定為非機要部門使用的數據加密標准，簡稱DES(Data Encrypton Standard)。自公布之日起，DES演算法作為國際上商用保密通信和計算機通信的最常用演算法，一直活躍在國際保密通信的舞台上，扮演了十分突出的角色。現將DES演算法簡單介紹一下，並給出實現DES演算法的VC源代碼。
DES演算法由加密、解密和子密鑰的生成三部分組成。

一．加密

DES演算法處理的數據對象是一組64比特的明文串。設該明文串為m=m1m2…m64 (mi=0或1)。明文串經過64比特的密鑰K來加密，最後生成長度為64比特的密文E。其加密過程圖示如下：

DES演算法加密過程
對DES演算法加密過程圖示的說明如下：待加密的64比特明文串m，經過IP置換後，得到的比特串的下標列表如下：

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

該比特串被分為32位的L0和32位的R0兩部分。R0子密鑰K1(子密鑰的生成將在後面講)經過變換f(R0,K1)（f變換將在下面講）輸出32位的比特串f1,f1與L0做不進位的二進制加法運算。運算規則為：

f1與L0做不進位的二進制加法運算後的結果賦給R1，R0則原封不動的賦給L1。L1與R0又做與以上完全相同的運算，生成L2，R2…… 一共經過16次運算。最後生成R16和L16。其中R16為L15與f(R15,K16)做不進位二進制加法運算的結果，L16是R15的直接賦值。

R16與L16合並成64位的比特串。值得注意的是R16一定要排在L16前面。R16與L16合並後成的比特串，經過置換IP-1後所得比特串的下標列表如下：
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

經過置換IP-1後生成的比特串就是密文e.。
下面再講一下變換f(Ri-1,Ki)。
它的功能是將32比特的輸入再轉化為32比特的輸出。其過程如圖所示：

對f變換說明如下：輸入Ri-1(32比特)經過變換E後，膨脹為48比特。膨脹後的比特串的下標列表如下：

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 31

膨脹後的比特串分為8組，每組6比特。各組經過各自的S盒後，又變為4比特(具體過程見後)，合並後又成為32比特。該32比特經過P變換後，其下標列表如下：

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

經過P變換後輸出的比特串才是32比特的f (Ri-1,Ki)。
下面再講一下S盒的變換過程。任取一S盒。見圖：

在其輸入b1,b2,b3,b4,b5,b6中，計算出x=b1*2+b6, y=b5+b4*2+b3*4+b2*8，再從Si表中查出x 行，y 列的值Sxy。將Sxy化為二進制，即得Si盒的輸出。（S表如圖所示）

至此，DES演算法加密原理講完了。在VC++6.0下的程序源代碼為：

for(i=1;i<=64;i++)
m1[i]=m[ip[i-1]];//64位明文串輸入，經過IP置換。

下面進行迭代。由於各次迭代的方法相同只是輸入輸出不同，因此只給出其中一次。以第八次為例：//進行第八次迭代。首先進行S盒的運算，輸入32位比特串。
for(i=1;i<=48;i++)//經過E變換擴充，由32位變為48位
RE1[i]=R7[E[i-1]];
for(i=1;i<=48;i++)//與K8按位作不進位加法運算
RE1[i]=RE1[i]+K8[i];
for(i=1;i<=48;i++)
{
if(RE1[i]==2)
RE1[i]=0;
}
for(i=1;i<7;i++)//48位分成8組
{
s11[i]=RE1[i];
s21[i]=RE1[i+6];
s31[i]=RE1[i+12];
s41[i]=RE1[i+18];
s51[i]=RE1[i+24];
s61[i]=RE1[i+30];
s71[i]=RE1[i+36];
s81[i]=RE1[i+42];
}//下面經過S盒，得到8個數。S1,s2,s3,s4,s5,s6,s7,s8分別為S表
s[1]=s1[s11[6]+s11[1]*2][s11[5]+s11[4]*2+s11[3]*4+s11[2]*8];
s[2]=s2[s21[6]+s21[1]*2][s21[5]+s21[4]*2+s21[3]*4+s21[2]*8];
s[3]=s3[s31[6]+s31[1]*2][s31[5]+s31[4]*2+s31[3]*4+s31[2]*8];
s[4]=s4[s41[6]+s41[1]*2][s41[5]+s41[4]*2+s41[3]*4+s41[2]*8];
s[5]=s5[s51[6]+s51[1]*2][s51[5]+s51[4]*2+s51[3]*4+s51[2]*8];
s[6]=s6[s61[6]+s61[1]*2][s61[5]+s61[4]*2+s61[3]*4+s61[2]*8];
s[7]=s7[s71[6]+s71[1]*2][s71[5]+s71[4]*2+s71[3]*4+s71[2]*8];
s[8]=s8[s81[6]+s81[1]*2][s81[5]+s81[4]*2+s81[3]*4+s81[2]*8];
for(i=0;i<8;i++)//8個數變換輸出二進制
{
for(j=1;j<5;j++)
{
temp[j]=s[i+1]%2;
s[i+1]=s[i+1]/2;
}
for(j=1;j<5;j++)
f[4*i+j]=temp[5-j];
}
for(i=1;i<33;i++)//經過P變換
frk[i]=f[P[i-1]];//S盒運算完成
for(i=1;i<33;i++)//左右交換
L8[i]=R7[i];
for(i=1;i<33;i++)//R8為L7與f(R,K)進行不進位二進制加法運算結果
{
R8[i]=L7[i]+frk[i];
if(R8[i]==2)
R8[i]=0;
}

[ 原創文檔 本文適合中級讀者 已閱讀21783次 ] 文檔 代碼 工具

DES演算法及其在VC++6.0下的實現(下)
作者：航天醫學工程研究所四室 朱彥軍

在《DES演算法及其在VC++6.0下的實現(上)》中主要介紹了DES演算法的基本原理，下面讓我們繼續：

二．子密鑰的生成
64比特的密鑰生成16個48比特的子密鑰。其生成過程見圖：

子密鑰生成過程具體解釋如下：
64比特的密鑰K，經過PC-1後，生成56比特的串。其下標如表所示：

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

該比特串分為長度相等的比特串C0和D0。然後C0和D0分別循環左移1位，得到C1和D1。C1和D1合並起來生成C1D1。C1D1經過PC-2變換後即生成48比特的K1。K1的下標列表為：

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

C1、D1分別循環左移LS2位，再合並，經過PC-2，生成子密鑰K2……依次類推直至生成子密鑰K16。
注意：Lsi (I =1,2,….16)的數值是不同的。具體見下表：

迭代順序 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

生成子密鑰的VC程序源代碼如下：

for(i=1;i<57;i++)//輸入64位K，經過PC-1變為56位 k0[i]=k[PC_1[i-1]];

56位的K0，均分為28位的C0，D0。C0，D0生成K1和C1，D1。以下幾次迭代方法相同，僅以生成K8為例。 for(i=1;i<27;i++)//循環左移兩位
{
C8[i]=C7[i+2];
D8[i]=D7[i+2];
}
C8[27]=C7[1];
D8[27]=D7[1];
C8[28]=C7[2];
D8[28]=D7[2];
for(i=1;i<=28;i++)
{
C[i]=C8[i];
C[i+28]=D8[i];
}
for(i=1;i<=48;i++)
K8[i]=C[PC_2[i-1]];//生成子密鑰k8

注意：生成的子密鑰不同，所需循環左移的位數也不同。源程序中以生成子密鑰 K8為例，所以循環左移了兩位。但在編程中，生成不同的子密鑰應以Lsi表為准。

三．解密

DES的解密過程和DES的加密過程完全類似，只不過將16圈的子密鑰序列K1，K2……K16的順序倒過來。即第一圈用第16個子密鑰K16，第二圈用K15，其餘類推。
第一圈：

加密後的結果

L=R15, R=L15⊕f(R15,K16)⊕f(R15,K16)=L15
同理R15=L14⊕f(R14,K15), L15=R14。
同理類推：
得 L=R0, R=L0。
其程序源代碼與加密相同。在此就不重寫。

四．示例
例如：已知明文m=learning, 密鑰 k=computer。
明文m的ASCII二進製表示：

m= 01101100 01100101 01100001 01110010
01101110 01101001 01101110 01100111

密鑰k的ASCII二進製表示：

k=01100011 01101111 01101101 01110000
01110101 01110100 01100101 01110010

明文m經過IP置換後，得：

11111111 00001000 11010011 10100110 00000000 11111111 01110001 11011000

等分為左右兩段：

L0=11111111 00001000 11010011 10100110 R0=00000000 11111111 01110001 11011000

經過16次迭代後，所得結果為：

L1=00000000 11111111 01110001 11011000 R1=00110101 00110001 00111011 10100101
L2=00110101 00110001 00111011 10100101 R2=00010111 11100010 10111010 10000111
L3=00010111 11100010 10111010 10000111 R3=00111110 10110001 00001011 10000100
L4= R4=
L5= R5=
L6= R6=
L7= R7=
L8= R8=
L9= R9=
L10= R10=
L11= R11=
L12= R12=
L13= R13=
L14= R14=
L15= R15=
L16= R16=

其中，f函數的結果為：

f1= f2=
f3= f4=
f5= f6=
f7= f8=
f9= f10=
f11= f12=
f13= f14=
f15= f16=

16個子密鑰為：

K1= K2=
K3= K4=
K5= K6=
K7= K8=
K9= K10=
K11= K12=
K13= K14=
K15= K16=

S盒中，16次運算時，每次的8 個結果為：
第一次：5，11，4，1，0，3，13，9；
第二次：7，13，15，8，12，12，13，1；
第三次：8，0，0，4，8，1，9，12；
第四次：0，7，4，1，7，6，12，4；
第五次：8，1，0，11，5，0，14，14；
第六次：14，12，13，2，7，15，14，10；
第七次：12，15，15，1，9，14，0，4；
第八次：15，8，8，3，2，3，14，5；
第九次：8，14，5，2，1，15，5，12；
第十次：2，8，13，1，9，2，10，2；
第十一次：10，15，8，2，1，12，12，3；
第十二次：5，4，4，0，14，10，7，4；
第十三次：2，13，10，9，2，4，3，13；
第十四次：13，7，14，9，15，0，1，3；
第十五次：3，1，15，5，11，9，11，4；
第十六次：12，3，4，6，9，3，3，0；

子密鑰生成過程中，生成的數值為：

C0=0000000011111111111111111011 D0=1000001101110110000001101000
C1=0000000111111111111111110110 D1=0000011011101100000011010001
C2=0000001111111111111111101100 D2=0000110111011000000110100010
C3=0000111111111111111110110000 D3=0011011101100000011010001000
C4=0011111111111111111011000000 D4=1101110110000001101000100000
C5=1111111111111111101100000000 D5=0111011000000110100010000011
C6=1111111111111110110000000011 D6=1101100000011010001000001101
C7=1111111111111011000000001111 D7=0110000001101000100000110111
C8=1111111111101100000000111111 D8=1000000110100010000011011101
C9=1111111111011000000001111111 D9=0000001101000100000110111011
C10=1111111101100000000111111111 D10=0000110100010000011011101100
C11=1111110110000000011111111111 D11=0011010001000001101110110000
C12=1111011000000001111111111111 D12=1101000100000110111011000000
C13=1101100000000111111111111111 D13=0100010000011011101100000011
C14=0110000000011111111111111111 D14=0001000001101110110000001101
C15=1000000001111111111111111101 D15=0100000110111011000000110100
C16=0000000011111111111111111011 D16=1000001101110110000001101000

解密過程與加密過程相反，所得的數據的順序恰好相反。在此就不贅述。

參考書目：
《計算機系統安全》 重慶出版社 盧開澄等編著
《計算機密碼應用基礎》 科學出版社 朱文余等編著
《Visual C++ 6.0 編程實例與技巧》 機械工業出版社 王華等編著

⑤ 用c語言寫des加密演算法

#include <stdio.h> #include <string.h> #include <windows.h> #include <conio.h> #include "Schedle.h" class CShift{ public: DWORDLONG mask[16]; int step[16]; CShift(){ for(int i=0;i<16;i++){ step[i]=2; mask[i]=0xc000000; } step[0]=step[1]=step[8]=step[15]=1; mask[0]=mask[1]=mask[8]=mask[15]=0x8000000; } }; class CDES{ public: CDES(){ m_dwlKey=0; m_dwlData=0; ConvertTableToMask(dwlKey_PC_1,64); //PrintTable(dwlKey_PC_1,7,8); ConvertTableToMask(dwlKey_PC_2,56); ConvertTableToMask(dwlData_IP,64); ConvertTableToMask(dwlData_Expansion,32); ConvertTableToMask(dwlData_FP,64); ConvertTableToMask(dwlData_P,32); Generate_S(); } void PrintBit(DWORDLONG); void EncryptKey(char *); unsigned char* EncryptData(unsigned char *); unsigned char* DescryptData(unsigned char*); private: void ConvertTableToMask(DWORDLONG *,int); void Generate_S(void); void PrintTable(DWORDLONG*,int,int); DWORDLONG ProcessByte(unsigned char*,BOOL); DWORDLONG PermuteTable(DWORDLONG,DWORDLONG*,int); void Generate_K(void); void EncryptKernel(void); DWORDLONG Generate_B(DWORDLONG,DWORDLONG*); /*For verify schele permutation only*/ DWORDLONG UnPermuteTable(DWORDLONG,DWORDLONG*,int); /**************************************/ DWORDLONG dwlData_S[9][4][16]; CShift m_shift; DWORDLONG m_dwlKey; DWORDLONG m_dwlData; DWORDLONG m_dwl_K[17]; }; void CDES::EncryptKey(char *key){ printf("\nOriginal Key: %s",key); m_dwlKey=ProcessByte((unsigned char*)key,TRUE); // PrintBit(m_dwlKey); m_dwlKey=PermuteTable(m_dwlKey,dwlKey_PC_1,56); // PrintBit(m_dwlKey); Generate_K(); // printf("\n******************************************\n"); } void CDES::Generate_K(void){ DWORDLONG C[17],D[17],tmp; C[0]=m_dwlKey>>28; D[0]=m_dwlKey&0xfffffff; for(int i=1;i<=16;i++){ tmp=(C[i-1]&m_shift.mask[i-1])>>(28-m_shift.step[i-1]); C[i]=((C[i-1]<<m_shift.step[i-1])|tmp)&0x0fffffff; tmp=(D[i-1]&m_shift.mask[i-1])>>(28-m_shift.step[i-1]); D[i]=((D[i-1]<<m_shift.step[i-1])|tmp)&0x0fffffff; m_dwl_K[i]=(C[i]<<28)|D[i]; m_dwl_K[i]=PermuteTable(m_dwl_K[i],dwlKey_PC_2,48); } } DWORDLONG CDES::ProcessByte(unsigned char *key,BOOL shift){ unsigned char tmp; DWORDLONG byte=0; int i=0; while(i<8){ while(*key){ if(byte!=0) byte<<=8; tmp=*key; if(shift) tmp<<=1; byte|=tmp; i++; key++; } if(i<8) byte<<=8; i++; } return byte; } DWORDLONG CDES::PermuteTable(DWORDLONG dwlPara,DWOR 基於des演算法的rfid安全系統
DLONG* dwlTable,int nDestLen){ int i=0; DWORDLONG tmp=0,moveBit; while(i<nDestLen){ moveBit=1; if(dwlTable[i]&dwlPara){ moveBit<<=nDestLen-i-1; tmp|=moveBit; } i++; } return tmp; } DWORDLONG CDES::UnPermuteTable(DWORDLONG dwlPara,DWORDLONG* dwlTable,int nDestLen){ DWORDLONG tmp=0; int i=nDestLen-1; while(dwlPara!=0){ if(dwlPara&0x01) tmp|=dwlTable[i]; dwlPara>>=1; i--; } return tmp; } void CDES::PrintTable(DWORDLONG *dwlPara,int col,int row){ int i,j; for(i=0;i<row;i++){ printf("\n"); getch(); for(j=0;j<col;j++) PrintBit(dwlPara[i*col+j]); } } void CDES::PrintBit(DWORDLONG bitstream){ char out[76]; int i=0,j=0,space=0; while(bitstream!=0){ if(bitstream&0x01) out[i++]='1'; else out[i++]='0'; j++; if(j%8==0){ out[i++]=' '; space++; } bitstream=bitstream>>1; } out[i]='\0'; strcpy(out,strrev(out)); printf("%s **:%d\n",out,i-space); } void CDES::ConvertTableToMask(DWORDLONG *mask,int max){ int i=0; DWORDLONG nBit=1; while(mask[i]!=0){ nBit=1; nBit<<=max-mask[i]; mask[i++]=nBit; } } void CDES::Generate_S(void){ int i; int j,m,n; m=n=0; j=1; for(i=0;i<512;i++){ dwlData_S[j][m][n]=OS[i]; n=(n+1)%16; if(!n){ m=(m+1)%4; if(!m) j++; } } } unsigned char * CDES::EncryptData(unsigned char *block){ unsigned char *EncrytedData=new unsigned char(15); printf("\nOriginal Data: %s\n",block); m_dwlData=ProcessByte(block,0); // PrintBit(m_dwlData); m_dwlData=PermuteTable(m_dwlData,dwlData_IP,64); EncryptKernel(); // PrintBit(m_dwlData); DWORDLONG bit6=m_dwlData; for(int i=0;i<11;i++){ EncrytedData[7-i]=(unsigned char)(bit6&0x3f)+46; bit6>>=6; } EncrytedData[11]='\0'; printf("\nAfter Encrypted: %s",EncrytedData); for(i=0;i<8;i++){ EncrytedData[7-i]=(unsigned char)(m_dwlData&0xff); m_dwlData>>=8; } EncrytedData[8]='\0'; return EncrytedData; } void CDES::EncryptKernel(void){ int i=1; DWORDLONG L[17],R[17],B[9],EK,PSB; L[0]=m_dwlData>>32; R[0]=m_dwlData&0xffffffff; for(i=1;i<=16;i++){ L[i]=R[i-1]; R[i-1]=PermuteTable(R[i-1],dwlData_Expansion,48); //Expansion R EK=R[i-1]^m_dwl_K[i]; //E Permutation PSB=Generate_B(EK,B); //P Permutation R[i]=L[i-1]^PSB; } R[16]<<=32; m_dwlData=R[16]|L[16]; m_dwlData=PermuteTable(m_dwlData,dwlData_FP,64); } unsigned char* CDES::DescryptData(unsigned char *desData){ int i=1; unsigned char *DescryptedData=new unsigned char(15); DWORDLONG L[17],R[17],B[9],EK,PSB; DWORDLONG dataPara; dataPara=ProcessByte(desData,0); dataPara=PermuteTable(dataPara,dwlData_IP,64); R[16]=dataPara>>32; L[16]=dataPara&0xffffffff; for(i=16;i>=1;i--){ R[i-1]=L[i]; L[i]=PermuteTable(L[i],dwlData_Expansion,48); //Expansion L EK=L[i]^m_dwl_K[i]; //E Permutation PSB=Generate_B(EK,B); //P Permutation L[i-1]=R[i]^PSB; } L[0]<<=32; dataPara=L[0]|R[0]; dataPara=PermuteTable(dataPara,dwlData_FP,64); // PrintBit(dataPara); for(i=0;i<8;i++){ DescryptedData[7-i]=(unsigned char)(dataPara&0xff); dataPara>>=8; } DescryptedData[8]='\0'; printf("\nAfter Decrypted: %s\n",DescryptedData); return DescryptedData; } DWORDLONG CDES::Generate_B(DWORDLONG EKPara,DWORDLONG *block){ int i,m,n; DWORDLONG tmp=0; for(i=8;i>0;i--){ block[i]=EKPara&0x3f; m=(int)(block[i]&0x20)>>4; m|=block[i]&0x01; n=(int)(block[i]<<1)>>2; block[i]=dwlData_S[i][m][n]; EKPara>>=6; } for(i=1;i<=8;i++){ tmp|=block[i]; tmp<<=4; } tmp>>=4; tmp=PermuteTable(tmp,dwlData_P,32); return tmp; } void main(void){ CDES des; des.EncryptKey("12345678"); unsigned char *result=des.EncryptData((unsigned char*)"DemoData"); des.DescryptData(result); }[1]

⑥ des加密演算法原理

DES加密演算法原理：

DES演算法使用一個56位的密鑰以及附加的8位奇偶校驗位，產生最大64位的分組大小。是一個迭代的分組密碼，其中將加密的文本亮散悔塊分成兩半。使用子密鑰對其中一半應用循環功能，然後將輸出與另一半進行「異或」運算；接著交換這兩半，這一過程會繼續下去，掘裂但最後一個循環不交換。DES使用16輪循環，使用異或，置換，代換，移位敬正操作四種基本運算。

⑦ DES加密演算法原理

網路安全通信中要用到兩類密碼演算法，一類是對稱密碼演算法，另一類是非對稱密碼演算法。對稱密碼演算法有時又叫傳統密碼演算法、秘密密鑰演算法或單密鑰演算法，非對稱密碼演算法也叫公開密鑰密碼演算法或雙密鑰演算法。對稱密碼演算法的加密密鑰能夠從解密密鑰中推算出來，反過來也成立。在大多數對稱演算法中，加密解密密鑰是相同的。它要求發送者和接收者在安全通信之前，商定一個密鑰。對稱演算法的安全性依賴於密鑰，泄漏密鑰就意味著任何人都能對消息進行加密解密。只要通信需要保密，密鑰就必須保密。

對稱演算法又可分為兩類。一次只對明文中的單個位（有時對位元組）運算的演算法稱為序列演算法或序列密碼。另一類演算法是對明文的一組位進行運算，這些位組稱為分組，相應的演算法稱為分組演算法或分組密碼。現代計算機密碼演算法的典型分組長度為64位――這個長度既考慮到分析破譯密碼的難度，又考慮到使用的方便性。後來，隨著破譯能力的發展，分組長度又提高到128位或更長。
常用的採用對稱密碼術的加密方案有5個組成部分（如圖所示）

1)明文：原始信息。
2)加密演算法：以密鑰為參數，對明文進行多種置換和轉換的規則和步驟，變換結果為密文。
3)密鑰：加密與解密演算法的參數，直接影響對明文進行變換的結果。
4)密文：對明文進行變換的結果。
5)解密演算法：加密演算法的逆變換，以密文為輸入、密鑰為參數，變換結果為明文。

對稱密碼當中有幾種常用到的數學運算。這些運算的共同目的就是把被加密的明文數碼盡可能深地打亂，從而加大破譯的難度。

◆移位和循環移位
移位就是將一段數碼按照規定的位數整體性地左移或右移。循環右移就是當右移時，把數碼的最後的位移到數碼的最前頭，循環左移正相反。例如，對十進制數碼12345678循環右移1位（十進制位）的結果為81234567，而循環左移1位的結果則為23456781。
◆置換
就是將數碼中的某一位的值根據置換表的規定，用另一位代替。它不像移位操作那樣整齊有序，看上去雜亂無章。這正是加密所需,被經常應用。
◆擴展
就是將一段數碼擴展成比原來位數更長的數碼。擴展方法有多種,例如,可以用置換的方法，以擴展置換表來規定擴展後的數碼每一位的替代值。
◆壓縮
就是將一段數碼壓縮成比原來位數更短的數碼。壓縮方法有多種，例如，也可以用置換的方法，以表來規定壓縮後的數碼每一位的替代值。
◆異或
這是一種二進制布爾代數運算。異或的數學符號為⊕ ，它的運演算法則如下：
1⊕1 = 0
0⊕0 = 0
1⊕0 = 1
0⊕1 = 1
也可以簡單地理解為，參與異或運算的兩數位如相等，則結果為0，不等則為1。
◆迭代
迭代就是多次重復相同的運算，這在密碼演算法中經常使用，以使得形成的密文更加難以破解。

下面我們將介紹一種流行的對稱密碼演算法DES。

DES是Data Encryption Standard（數據加密標准）的縮寫。它是由IBM公司研製的一種對稱密碼演算法，美國國家標准局於1977年公布把它作為非機要部門使用的數據加密標准，三十年來，它一直活躍在國際保密通信的舞台上，扮演了十分重要的角色。

DES是一個分組加密演算法，典型的DES以64位為分組對數據加密，加密和解密用的是同一個演算法。它的密鑰長度是56位（因為每個第8 位都用作奇偶校驗），密鑰可以是任意的56位的數，而且可以任意時候改變。其中有極少數被認為是易破解的弱密鑰，但是很容易避開它們不用。所以保密性依賴於密鑰。

DES加密的演算法框架如下：
首先要生成一套加密密鑰，從用戶處取得一個64位長的密碼口令，然後通過等分、移位、選取和迭代形成一套16個加密密鑰，分別供每一輪運算中使用。

DES對64位(bit)的明文分組M進行操作，M經過一個初始置換IP，置換成m0。將m0明文分成左半部分和右半部分m0 = (L0，R0)，各32位長。然後進行16輪完全相同的運算（迭代），這些運算被稱為函數f，在每一輪運算過程中數據與相應的密鑰結合。

在每一輪中，密鑰位移位，然後再從密鑰的56位中選出48位。通過一個擴展置換將數據的右半部分擴展成48位，並通過一個異或操作替代成新的48位數據，再將其壓縮置換成32位。這四步運算構成了函數f。然後，通過另一個異或運算，函數f的輸出與左半部分結合，其結果成為新的右半部分，原來的右半部分成為新的左半部分。將該操作重復16次。

經過16輪迭代後，左，右半部分合在一起經過一個末置換（數據整理），這樣就完成了加密過程。
加密流程如圖所示。

DES解密過程：
在了解了加密過程中所有的代替、置換、異或和循環迭代之後，讀者也許會認為，解密演算法應該是加密的逆運算，與加密演算法完全不同。恰恰相反，經過密碼學家精心設計選擇的各種操作，DES獲得了一個非常有用的性質：加密和解密使用相同的演算法！

DES加密和解密唯一的不同是密鑰的次序相反。如果各輪加密密鑰分別是K1，K2，K3…K16，那麼解密密鑰就是K16，K15，K14…K1。這也就是DES被稱為對稱演算法的理由吧。

至於對稱密碼為什麼能對稱? DES具體是如何操作的？本文附錄中將做進一步介紹，有興趣的讀者不妨去讀一讀探個究竟

4.DES演算法的安全性和發展
DES的安全性首先取決於密鑰的長度。密鑰越長，破譯者利用窮舉法搜索密鑰的難度就越大。目前，根據當今計算機的處理速度和能力，56位長度的密鑰已經能夠被破解，而128位的密鑰則被認為是安全的，但隨著時間的推移，這個數字也遲早會被突破。

另外，對DES演算法進行某種變型和改進也是提高DES演算法安全性的途徑。

例如後來演變出的3-DES演算法使用了3個獨立密鑰進行三重DES加密，這就比DES大大提高了安全性。如果56位DES用窮舉搜索來破譯需要2∧56次運算，而3-DES 則需要2∧112次。

又如，獨立子密鑰DES由於每輪都使用不同的子密鑰，這意味著其密鑰長度在56位的基礎上擴大到768位。DES還有DESX、CRYPT、GDES、RDES等變型。這些變型和改進的目的都是為了加大破譯難度以及提高密碼運算的效率

⑧ 對稱加密演算法之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演算法是什麼

DES演算法為密碼體制中的對稱密碼體制。

DES演算法為密碼體制中的對稱密碼體制，又被稱為美國數據加密標准，是1972年美國IBM公司研製的對稱密碼體制加密演算法。明文按64位進行分組，密鑰長64位，密鑰事實上是56位參與DES運算，分組後的明文組和56位的密鑰按位替代或交換的方法形成密文組的加密方法。

des的應用領域

計算機網路通信：對計算機網路通信中的數據提供保護是DES的一項重要應用。但這些被保護的數據一般只限於民用敏感信息，即不在政府確定的保密范圍之內的信息。

電子資金傳送系統：採用DES的方法加密電子資金傳送系統中的信息，可准確、快速地傳送數據，並可較好地解決信息安全的問題。

保護用戶文件：用戶可自選密鑰對重要文件加密，防止未授權用戶竊密。

用戶識別：DES還可用於計算機用戶識別系統中。

⑩ DES加密演算法C語言實現

#include<iostream.h>
class SubKey{ //定義子密鑰為一個類
public:
int key[8][6];
}subkey[16]; //定義子密鑰對象數組

class DES{
int encipher_decipher; //判斷加密還是解密
int key_in[8][8]; //用戶原始輸入的64位二進制數
int key_out[8][7]; //除去每行的最後一位校驗位
int c0_d0[8][7]; //存儲經PC-1轉換後的56位數據
int c0[4][7],d0[4][7]; //分別存儲c0,d0
int text[8][8]; //64位明文
int text_ip[8][8]; //經IP轉換過後的明文
int A[4][8],B[4][8]; //A,B分別存儲經IP轉換過後明文的兩部分,便於交換
int temp[8][6]; //存儲經擴展置換後的48位二進制值
int temp1[8][6]; //存儲和子密鑰異或後的結果
int s_result[8][4]; //存儲經S變換後的32位值
int text_p[8][4]; //經P置換後的32位結果
int secret_ip[8][8]; //經逆IP轉換後的密文
public:
void Key_Putting();
void PC_1();
int function(int,int); //異或
void SubKey_Proction();
void IP_Convert();
void f();
void _IP_Convert();
void Out_secret();
};
void DES::Key_Putting() //得到密鑰中對演算法有用的56位
{
cout<<"請輸入64位的密鑰(8行8列且每行都得有奇數個1):\n";
for(int i=0;i<8;i++)
for(int j=0;j<8;j++){
cin>>key_in[i][j];
if(j!=7) key_out[i][j]=key_in[i][j];
}
}
void DES::PC_1() //PC-1置換函數
{
int pc_1[8][7]={ //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}
};
int i,j;
for(i=0;i<8;i++)
for(j=0;j<7;j++)
c0_d0[i][j]=key_out[ (pc_1[i][j]-1)/8 ][ (pc_1[i][j]-1)%8 ];
}
int DES::function(int a,int b) //模擬二進制數的異或運算,a和b為整型的0和1,返回值為整型的0或1
{
if(a!=b)return 1;
else return 0;
}
void DES::SubKey_Proction() //生成子密鑰
{
int move[16][2]={ //循環左移的位數
1 , 1 , 2 , 1 ,
3 , 2 , 4 , 2 ,
5 , 2 , 6 , 2 ,
7 , 2 , 8 , 2 ,
9 , 1, 10 , 2,
11 , 2, 12 , 2,
13 , 2, 14 , 2,
15 , 2, 16 , 1
};
int pc_2[8][6]={ //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
};
for(int i=0;i<16;i++) //生成子密鑰
{
int j,k;
int a[2],b[2];
int bb[28],cc[28];
for(j=0;j<4;j++)
for(k=0;k<7;k++)
c0[j][k]=c0_d0[j][k];
for(j=4;j<8;j++)
for(k=0;k<7;k++)
d0[j-4][k]=c0_d0[j][k];
for(j=0;j<4;j++)
for(k=0;k<7;k++){
bb[7*j+k]=c0[j][k];
cc[7*j+k]=d0[j][k];
}
for(j=0;j<move[i][1];j++){
a[j]=bb[j];
b[j]=cc[j];
}
for(j=0;j<28-move[i][1];j++){
bb[j]=bb[j+1];
cc[j]=cc[j+1];
}
for(j=0;j<move[i][1];j++){
bb[27-j]=a[j];
cc[27-j]=b[j];
}
for(j=0;j<28;j++){
c0[j/7][j%7]=bb[j];
d0[j/7][j%7]=cc[j];
}
for(j=0;j<4;j++) //L123--L128是把c0,d0合並成c0_d0
for(k=0;k<7;k++)
c0_d0[j][k]=c0[j][k];
for(j=4;j<8;j++)
for(k=0;k<7;k++)
c0_d0[j][k]=d0[j-4][k];
for(j=0;j<8;j++) //對Ci,Di進行PC-2置換
for(k=0;k<6;k++)
subkey[i].key[j][k]=c0_d0[ (pc_2[j][k]-1)/7 ][ (pc_2[j][k]-1)%7 ];
}
}
void DES::IP_Convert()
{
int IP[8][8]={ //初始置換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
};
cout<<"你好,你要加密還是解密?加密請按1號鍵(輸入1),解密請按2號鍵,並確定."<<'\n';
cin>>encipher_decipher;
char * s;
if(encipher_decipher==1) s="明文";
else s="密文";
cout<<"請輸入64位"<<s<<"(二進制):\n";
int i,j;
for(i=0;i<8;i++)
for(j=0;j<8;j++)
cin>>text[i][j];
for(i=0;i<8;i++) //進行IP變換
for(j=0;j<8;j++)
text_ip[i][j]=text[ (IP[i][j]-1)/8 ][ (IP[i][j]-1)%8 ];
}