des加密
㈠ DES加密問題
DES對64位二進制數據加密,產生64位密文數據,實際密鑰長度為56位(有8位用於奇偶校驗,解密時的過程和加密時相似,但密鑰的順序正好相反),這個標准由美國國家安全局和國家標准與技術局來管理。DES的成功應用是在銀行業中的電子資金轉賬(EFT)領域中。現在DES也可由硬體實現,AT&T首先用LSI晶元實現了DES的全部工作模式,該產品稱為數據加密處理機DEP。另一個系統是國際數據加密演算法(IDEA),它比DES的加密性好,而且計算機功能也不需要那麼強。在未來,它的應用將被推廣到各個領域。IDEA加密標准由PGP(Pretty Good Privacy)系統使用,PGP是一種可以為普通電子郵件用戶提供加密、解密方案的安全系統。在PGP系統中,使用IDEA(分組長度128bit)、RSA(用於數字簽名、密鑰管理)、MD5(用於數據壓縮)演算法,它不但可以對你的郵件保密以防止非授權者閱讀,還能對你的郵件加以數字簽名從而使收信人確信郵件是由你發出。--
㈡ 關於DES加密演算法
數據加密演算法
數據加密演算法DES
數據加密演算法(Data Encryption Algorithm,DEA)的數據加密標准(Data Encryption Standard,DES)是規范的描述,它出自 IBM 的研究工作,並在 1997 年被美國政府正式採納。它很可能是使用最廣泛的秘鑰系統,特別是在保護金融數據的安全中,最初開發的 DES 是嵌入硬 件中的。通常,自動取款機(Automated Teller Machine,ATM)都使用 DES。
DES 使用一個 56 位的密鑰以及附加的 8 位奇偶校驗位,產生最大 64 位的分組大小。這是一個迭代的分組密碼,使用稱為 Feistel 的技術,其中將加密的文本塊分成兩半。使用子密鑰對其中一半應用循環功能,然後將輸出與另一半進行「異或」運算;接著交換這兩半,這一過程會繼續下去,但最後一個循環不交換。DES 使用 16 個循環。
攻擊 DES 的主要形式被稱為蠻力的或徹底密鑰搜索,即重復嘗試各種密鑰直到有一個符合為止。如果 DES 使用 56 位的密鑰,則可能的密鑰數量是 2 的 56 次方個。隨著計算機系統能力的不斷發展,DES 的安全性比它剛出現時會弱得多,然而從非關鍵性質的實際出發,仍可以認為它是足夠的。不過 ,DES 現在僅用於舊系統的鑒定,而更多地選擇新的加密標准 — 高級加密標准(Advanced Encryption Standard,AES)。
DES 的常見變體是三重 DES,使用 168 位的密鑰對資料進行三次加密的一種機制;它通常(但非始終)提供極其強大的安全性。如果三個 56 位的子元素都相同,則三重 DES 向後兼容 DES。
IBM 曾對 DES 擁有幾年的專利權,但是在 1983 年已到期,並且處於公有范圍中,允許在特定條件下可以免除專利使用費而使用。
㈢ des加密演算法流程圖
DES(Data Encryption Standard)滿足了國家標准局欲達到的4個目的:提供高質量的數據保護,防止數據未經授權的泄露和未被察覺的修改;具有相當高的復雜性,使得破譯的開銷超過可能獲得的利益,同時又要便於理解和掌握;
DES演算法把64位的明文輸入塊變為64位的密文輸出塊,它所使用的密鑰也是64位,首先,DES把輸入的64位數據塊按位重新組合,並把輸出分為L0、R0兩部分,每部分各長32位,並進行前後置換(輸入的第58位換到第一位,第50位換到第2位,依此類推,最後一位是原來的第7位),最終由L0輸出左32位,R0輸出右32位,根據這個法則經過16次迭代運算後,得到L16、R16,將此作為輸入,進行與初始置換相反的逆置換,即得到密文輸出。
DES演算法的入口參數有三個:Key、Data、Mode。其中Key為8個位元組共64位,是DES演算法的工作密鑰;Data也為8個位元組64位,是要被加密或被解密的數據;Mode為DES的工作方式,有兩種:加密或解密,如果Mode為加密,則用Key去把數據Data進行加密,生成Data的密碼形式作為DES的輸出結果;如Mode為解密,則用Key去把密碼形式的數據Data解密,還原為Data的明碼形式作為DES的輸出結果。在使用DES時,雙方預先約定使用的」密碼」即Key,然後用Key去加密數據;接收方得到密文後使用同樣的Key解密得到原數據,這樣便實現了安全性較高的數據傳輸。
㈣ 什麼是DES加密
一種對稱加密演算法,DES 使用一個 56 位的密鑰以及附加的 8 位奇偶校驗位,產生最大 64 位的分組大小。這是一個迭代的分組密碼,使用稱為 Feistel 的技術,其中將加密的文本塊分成兩半。使用子密鑰對其中一半應用循環功能,然後將輸出與另一半進行「異或」運算;接著交換這兩半,這一過程會繼續下去,但最後一個循環不交換。DES 使用 16 個循環,使用異或,置換,代換,移位操作四種基本運算。
㈤ DES加密演算法 優點缺點
優點:DES加密演算法密鑰只用到了64位中的56位,這樣具有高的安全性。
缺點:分組比較短、密鑰太短、密碼生命周期短、運算速度較慢。
㈥ 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 編程實例與技巧》 機械工業出版社 王華等編著
㈦ DES加密演算法
特點
分組比較短、密鑰太短、密碼生命周期短、運算速度較慢。
編輯本段基本原理
入口參數有三個:key、data、mode。 key為加密解密使用的密鑰,data為加密解密的數據,mode為其工作模式。當模式為加密模式時,明文按照64位進行分組,形成明文組,key用於對數據加密,當模式為解密模式時,key用於對數據解密。實際運用中,密鑰只用到了64位中的56位,這樣才具有高的安全性。 DES( Data Encryption Standard)演算法,於1977年得到美國政府的正式許可,是一種用56位密鑰來加密64位數據的方法。雖然56位密鑰的DES演算法已經風光不在,而且常有用Des加密的明文被破譯的報道,但是了解一下昔日美國的標准加密演算法總是有益的,而且目前DES演算法得到了廣泛的應用,在某些場合,仍然發揮著余熱。
編輯本段密鑰生成
取得密鑰
從用戶處取得一個64位(本文如未特指,均指二進制位))長的密碼key ,去除64位密碼中作為奇偶校驗位的第8、16、24、32、40、48、56、64位,剩下的56位作為有效輸入密鑰.
等分密鑰
表1. DES加密演算法
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 50 44 36 表2. 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步中生成的56位輸入密鑰分成均等的A,B兩部分,每部分為28位,參照表1和表2把輸入密鑰的位值填入相應的位置. 按照表1所示A的第一位為輸入的64位密鑰的第57位,A的第2位為64位密鑰的第49位,...,依此類推,A的最後一位最後一位是64位密鑰的第36位。
密鑰移位
表3. i 1 2 3 4 5 6 7 8 DES加密演算法
ǿ 1 1 2 2 2 2 2 2 i 9 10 11 12 13 14 15 16 ǿ 1 2 2 2 2 2 2 1 DES演算法的密鑰是經過16次迭代得到一組密鑰的,把在1.1.2步中生成的A,B視為迭代的起始密鑰,表3顯示在第i次迭代時密鑰循環左移的位數. 比如在第1次迭代時密鑰循環左移1位,第3次迭代時密鑰循環左移2位. 第9次迭代時密鑰循環左移1位,第14次迭代時密鑰循環左移2位. 第一次迭代: A(1) = ǿ(1) A B(1) = ǿ(1) B DES加密演算法
第i次迭代: A(i) = ǿ(i) A(i-1) B(i) = ǿ(i) B(i-1)
實現介面函數的介紹
1 int des(char *data, char *key,int readlen) 參數: 1.存放待加密明文的內存指針(長度為readlen,可能經過填充; 2.存放用戶輸入的密鑰內存的指針 3.待加密明文的長度(8位元組的倍數) 功能: 生成加密密鑰,把待加密的明文數據分割成64位的塊,逐塊完成16次迭代加密,密文存放在data所指向的內存中. 2 int Ddes(char *data, char *key,int readlen) 參數: 1.存放待解密文的內存指針(長度為readlen,可能經過填充; 2.存放用戶輸入的密鑰內存的指針 3.待解密文的長度( 8位元組的倍數) 功能: 生成解密密鑰,把待解密文分割成64位的塊,逐塊完成16次迭代解密,解密後的明文存放在data所指向的內存中. 3 int des3(char *data, char *key, int n ,int readlen) 參數: 1.存放待加密明文的內存指針(長度為readlen,可能經過填充; 2.存放用戶輸入的密鑰內存的指針 DES加密演算法
3.用戶指定進行多少層加密 4.待加密明文的長度(8位元組的倍數) 功能: 生成加密密鑰,把待加密的明文分割成64位的塊,把第i-1層加密後的密文作為第i層加密的明文輸入,根據用戶指定的加密層數進行n層加密,最終生成的密文存放在data所指向的內存中. 說明: 用戶僅僅輸入一條密鑰,所有的加密密鑰都是由這條密鑰生成. 4 int Ddes3(char *data, char*key, int n ,int readlen) 參數: 1.存放待解密文的內存指針(長度為readlen,可能經過填充; 2.存放用戶輸入的密鑰內存的指針 3.用戶指定進行多少層解密 4.待解密文的長度(8位元組的倍數) 功能: 生成解密密鑰,把待解密文分割成64位的塊,把第i-1層解密後的"明文"作為第i層解密的密文輸入,根據用戶指定的解密層數進行n層解密,最終生成的明文存放在data所指向的內存中. 說明: 用戶僅僅輸入一條密鑰,所有的解密密鑰都是由這條密鑰生成. 5 int desN(char*data,char**key,int n_key,int readlen) 參數: 1.存放待加密明文的內存指針(長度為readlen,可能經過填充; 2.存放用戶輸入的密鑰內存的指針 3.用戶指定了多少條密鑰 4.待加密明文的長度(8位元組的倍數) 功能: DES加密演算法生成加密密鑰,把待加密的明文分割成64位的塊,把第i-1層加密後的密文作為第i層加密的明文輸入,根據用戶指定的加密層數進行n層加密,最終生成的密文存放在data所指向的內存中. 說明: 這里用戶通過輸入的密鑰條數決定加密的層數,每輪16次迭代加密所使用的加密密鑰是由用戶自定的對應密鑰生成. 6 int DdesN(char*data,char**key,intn_key,int readlen) 參數: 1.存放待解密文的內存指針(長度為readlen,可能經過填充; 2.存放用戶輸入的密鑰內存的指針 3.用戶指定了多少條密鑰 4.待解密文的長度(8位元組的倍數) 功能: 生成解密密鑰,把待解密文分割成64位的塊,把第i-1層解密後的」明文」作為第i層解密的密文輸入,根據用戶指定的解密層數進行n層解密,最終生成的明文存放在data所指向的內存中. 說明: 這里用戶通過輸入的密鑰條數決定解密的層數,每輪16次迭代加密所使用的解密密鑰是由用戶自定的對應密鑰生成. DES加密演算法-實現的介紹 利用演算法核心代碼封裝的介面函數編寫了一個針對文本文件的加密解密工具。選擇把密文以16進制的形式寫入文件的方法.當然也可以直接寫入文件. 例: DES加密演算法
密文為:12345678 在內存中顯示為: 31 32 33 34 35 36 37 38 那麼就把以3132333435363738的形式寫入文件. 為了解密的方便,密文中的每個位元組用兩個位元組表示,也即在內存中顯示為0x9A的內容,就以9A的形式寫入文件中.當內存中顯示的內容為0x0?(?代表0~F)形式時,需要以0?的形式寫入文件. 這樣可以避開前面提及的問題,只是在解密時先按照兩兩組合的原則,順序把從文件中讀取的數據轉換成待解的密文. 例: 讀出的數據是: 3132333435363738 那麼復原的過程: 31->1 32->2 33->3 …. 38->8 最終得真正的密文12345678,這樣就可以調用DES演算法解密函數從密文得到明文. DES演算法是對固定大小(64位)的數據塊進行加密解密操作的,對於那些不夠64位的數據塊需要採用填充機制補位到64位長,為了方便使用,數據位的填充是對用戶而言是透明的,利用該工具進行加密解密操作時,用戶只需輸入操作的類型、讀取數據的文件名、寫入操作結果的文件名、密鑰等信息.
編輯本段操作思路
#define READFILESIZE 512 步驟: 1.從文件中讀取READFILESIZE個位元組的數據 2.,如果從文件中讀出的數據少於READFILESIZE個,以0補足,然後根據用戶指定的類型對這READFILESIZE個位元組的數據進行操作. 3.判斷文件是否結束,沒有則執行步驟1 4.把加密後的文件實際長度添加到密文的末尾 5.結束 採用一次只從文件讀取READFILESIZE個位元組是在為了防止由於需要加密或解密的文件太大導致內存不夠的情況出現。 DES加密演算法-注意事項 DES演算法的加密密鑰是根據用戶輸入的密碼生成的,該演算法把64位密碼中的第8位、第16位、第24位、第32位、第40位、第48位、第56位、第64位作為奇偶校驗位,在計算密鑰時要忽略這8位.如果輸入的密碼只是在這8位上有區別的話,那麼操作後的結果將是一樣的. 例: 輸入的密碼為wuzhenll,密鑰的16進製表示為77 75 7A 68 65 6E 6C 6C 任意改變這64位數據的奇偶校驗位,可以得到16個不同的密碼, 把8個奇偶檢驗位全取反後: w->v u->t z->{ h->i e->d n->o l->m 形成新密碼:vt{idomm 表面上新密碼和原密碼迥然不同,但是由於他們僅在奇偶校驗位上有區別,所以用這兩個密碼進行加密解密操作得到的結果是一樣的. 筆者建議使用安全系數較高的多密鑰加密解密方案. 此外用戶輸入的密碼的長度不受限制,當輸入的密碼長度為0時,使用預設64位密碼;當輸入的密碼長度大於8位元組時,輸入密碼的前8個位元組為有效密碼. 該工具提供6種不同的操作類型: 1:一層加密; 2:一層解密; 3:N層單密鑰加密; 4:N層單密鑰解密; 5:N層多密鑰加密; 6:N層多密鑰解密; 這六種操作是對稱使用的,例如:加密明文時選擇一層加密,解密時對密文使用一層解密
㈧ DES加密解密是不是對加密的字元串長度有限制
對這方面不熟,基本原理就是自己定義個運算規則,可以逆運算的。寫了個簡單的例子,大概就這樣。 String s = "abcd"; // 加密 char[] chs = s.toCharArray(); for (int i = 0; i < chs.length; i++) { chs[i] = (char) (chs[i] ^ '0'); } // 解
㈨ DES加密 中文亂碼
讀取的時候使用位元組流,加密之後保存到另一個文件也使用位元組寫進去,解密的時候位元組流出來解了之後然後將位元組數組使用new String(byte[])來生成String應該就不會出問題了。
㈩ des加密演算法(c/c++)
des.h文件:
#ifndefCRYPTOPP_DES_H
#defineCRYPTOPP_DES_H
#include"cryptlib.h"
#include"misc.h"
NAMESPACE_BEGIN(CryptoPP)
classDES:publicBlockTransformation
{
public:
DES(constbyte*userKey,CipherDir);
voidProcessBlock(constbyte*inBlock,byte*outBlock)const;
voidProcessBlock(byte*inoutBlock)const
{DES::ProcessBlock(inoutBlock,inoutBlock);}
enum{KEYLENGTH=8,BLOCKSIZE=8};
unsignedintBlockSize()const{returnBLOCKSIZE;}
protected:
staticconstword32Spbox[8][64];
SecBlock<word32>k;
};
classDESEncryption:publicDES
{
public:
DESEncryption(constbyte*userKey)
:DES(userKey,ENCRYPTION){}
};
classDESDecryption:publicDES
{
public:
DESDecryption(constbyte*userKey)
:DES(userKey,DECRYPTION){}
};
classDES_EDE_Encryption:publicBlockTransformation
{
public:
DES_EDE_Encryption(constbyte*userKey)
:e(userKey,ENCRYPTION),d(userKey+DES::KEYLENGTH,DECRYPTION){}
voidProcessBlock(constbyte*inBlock,byte*outBlock)const;
voidProcessBlock(byte*inoutBlock)const;
enum{KEYLENGTH=16,BLOCKSIZE=8};
unsignedintBlockSize()const{returnBLOCKSIZE;}
private:
DESe,d;
};
classDES_EDE_Decryption:publicBlockTransformation
{
public:
DES_EDE_Decryption(constbyte*userKey)
:d(userKey,DECRYPTION),e(userKey+DES::KEYLENGTH,ENCRYPTION){}
voidProcessBlock(constbyte*inBlock,byte*outBlock)const;
voidProcessBlock(byte*inoutBlock)const;
enum{KEYLENGTH=16,BLOCKSIZE=8};
unsignedintBlockSize()const{returnBLOCKSIZE;}
private:
DESd,e;
};
classTripleDES_Encryption:publicBlockTransformation
{
public:
TripleDES_Encryption(constbyte*userKey)
:e1(userKey,ENCRYPTION),d(userKey+DES::KEYLENGTH,DECRYPTION),
e2(userKey+2*DES::KEYLENGTH,ENCRYPTION){}
voidProcessBlock(constbyte*inBlock,byte*outBlock)const;
voidProcessBlock(byte*inoutBlock)const;
enum{KEYLENGTH=24,BLOCKSIZE=8};
unsignedintBlockSize()const{returnBLOCKSIZE;}
private:
DESe1,d,e2;
};
classTripleDES_Decryption:publicBlockTransformation
{
public:
TripleDES_Decryption(constbyte*userKey)
:d1(userKey+2*DES::KEYLENGTH,DECRYPTION),e(userKey+DES::KEYLENGTH,ENCRYPTION),
d2(userKey,DECRYPTION){}
voidProcessBlock(constbyte*inBlock,byte*outBlock)const;
voidProcessBlock(byte*inoutBlock)const;
enum{KEYLENGTH=24,BLOCKSIZE=8};
unsignedintBlockSize()const{returnBLOCKSIZE;}
private:
DESd1,e,d2;
};
NAMESPACE_END
#endif
des.cpp文件:
//des.cpp-modifiedbyWeiDaifrom:
/*
*
*circa1987,'s1977
*publicdomaincode.,but
*theactualencrypt/
*Outerbridge'sDEScodeasprintedinSchneier's"AppliedCryptography."
*
*Thiscodeisinthepublicdomain.Iwouldappreciatebugreportsand
*enhancements.
*
*PhilKarnKA9Q,[email protected],August1994.
*/
#include"pch.h"
#include"misc.h"
#include"des.h"
NAMESPACE_BEGIN(CryptoPP)
/*
*Threeofthesetables,theinitialpermutation,thefinal
*,areregularenoughthat
*forspeed,wehard-codethem.They'rehereforreferenceonly.
*Also,,gensp.c,
*tobuildthecombinedSPbox,Spbox[].They'realsoherejust
*forreference.
*/
#ifdefnotdef
/*initialpermutationIP*/
staticbyteip[]={
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
};
/*finalpermutationIP^-1*/
staticbytefp[]={
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
};
/*expansionoperationmatrix*/
staticbyteei[]={
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
};
/*The(in)famousS-boxes*/
staticbytesbox[8][64]={
/*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
};
/*32--boxes*/
staticbytep32i[]={
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
};
#endif
/*permutedchoicetable(key)*/
staticconstbytepc1[]={
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
};
/*numberleftrotationsofpc1*/
staticconstbytetotrot[]={
1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28
};
/*permutedchoicekey(table)*/
staticconstbytepc2[]={
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
};
/*EndofDES-definedtables*/
/*bit0isleft-mostinbyte*/
staticconstintbytebit[]={
0200,0100,040,020,010,04,02,01
};
/*Setkey(initializekeyschelearray)*/
DES::DES(constbyte*key,CipherDirdir)
:k(32)
{
SecByteBlockbuffer(56+56+8);
byte*constpc1m=buffer;/*placetomodifypc1into*/
byte*constpcr=pc1m+56;/*placetorotatepc1into*/
byte*constks=pcr+56;
registerinti,j,l;
intm;
for(j=0;j<56;j++){/*convertpc1tobitsofkey*/
l=pc1[j]-1;/*integerbitlocation*/
m=l&07;/*findbit*/
pc1m[j]=(key[l>>3]&/*findwhichkeybytelisin*/
bytebit[m])/*andwhichbitofthatbyte*/
?1:0;/*andstore1-bitresult*/
}
for(i=0;i<16;i++){/*keychunkforeachiteration*/
memset(ks,0,8);/*Clearkeyschele*/
for(j=0;j<56;j++)/*rotatepc1therightamount*/
pcr[j]=pc1m[(l=j+totrot[i])<(j<28?28:56)?l:l-28];
/**/
for(j=0;j<48;j++){/*selectbitsindivially*/
/*checkbitthatgoestoks[j]*/
if(pcr[pc2[j]-1]){
/*maskitinifit'sthere*/
l=j%6;
ks[j/6]|=bytebit[l]>>2;
}
}
/*Nowconverttoodd/eveninterleavedformforuseinF*/
k[2*i]=((word32)ks[0]<<24)
|((word32)ks[2]<<16)
|((word32)ks[4]<<8)
|((word32)ks[6]);
k[2*i+1]=((word32)ks[1]<<24)
|((word32)ks[3]<<16)
|((word32)ks[5]<<8)
|((word32)ks[7]);
}
if(dir==DECRYPTION)//reversekeyscheleorder
for(i=0;i<16;i+=2)
{
std::swap(k[i],k[32-2-i]);
std::swap(k[i+1],k[32-1-i]);
}
}
/**/
/*Ccodeonlyinportableversion*/
//RichardOuterbridge'sinitialpermutationalgorithm
/*
inlinevoidIPERM(word32&left,word32&right)
{
word32work;
work=((left>>4)^right)&0x0f0f0f0f;
right^=work;
left^=work<<4;
work=((left>>16)^right)&0xffff;
right^=work;
left^=work<<16;
work=((right>>2)^left)&0x33333333;
left^=work;
right^=(work<<2);
work=((right>>8)^left)&0xff00ff;
left^=work;
right^=(work<<8);
right=rotl(right,1);
work=(left^right)&0xaaaaaaaa;
left^=work;
right^=work;
left=rotl(left,1);
}
inlinevoidFPERM(word32&left,word32&right)
{
word32work;
right=rotr(right,1);
work=(left^right)&0xaaaaaaaa;
left^=work;
right^=work;
left=rotr(left,1);
work=((left>>8)^right)&0xff00ff;
right^=work;
left^=work<<8;
work=((left>>2)^right)&0x33333333;
right^=work;
left^=work<<2;
work=((right>>16)^left)&0xffff;
left^=work;
right^=work<<16;
work=((right>>4)^left)&0x0f0f0f0f;
left^=work;
right^=work<<4;
}
*/
//WeiDai''sinitialpermutation
//algorithm,
//(likeinMSVC)
inlinevoidIPERM(word32&left,word32&right)
{
word32work;
right=rotl(right,4U);
work=(left^right)&0xf0f0f0f0;
left^=work;
right=rotr(right^work,20U);
work=(left^right)&0xffff0000;
left^=work;
right=rotr(right^work,18U);
work=(left^right)&0x33333333;
left^=work;
right=rotr(right^work,6U);
work=(left^right)&0x00ff00ff;
left^=work;
right=rotl(right^work,9U);
work=(left^right)&0xaaaaaaaa;
left=rotl(left^work,1U);
right^=work;
}
inlinevoidFPERM(word32&left,word32&right)
{
word32work;
right=rotr(right,1U);
work=(left^right)&0xaaaaaaaa;
right^=work;
left=rotr(left^work,9U);
work=(left^right)&0x00ff00ff;
right^=work;
left=rotl(left^work,6U);
work=(left^right)&0x33333333;
right^=work;
left=rotl(left^work,18U);
work=(left^right)&0xffff0000;
right^=work;
left=rotl(left^work,20U);
work=(left^right)&0xf0f0f0f0;
right^=work;
left=rotr(left^work,4U);
}
//
voidDES::ProcessBlock(constbyte*inBlock,byte*outBlock)const
{
word32l,r,work;
#ifdefIS_LITTLE_ENDIAN
l=byteReverse(*(word32*)inBlock);
r=byteReverse(*(word32*)(inBlock+4));
#else
l=*(word32*)inBlock;
r=*(word32*)(inBlock+4);
#endif
IPERM(l,r);
constword32*kptr=k;
for(unsignedi=0;i<8;i++)
{
work=rotr(r,4U)^kptr[4*i+0];
l^=Spbox[6][(work)&0x3f]
^Spbox[4][(work>>8)&0x3f]
^Spbox[2][(work>>16)&0x3f]
^Spbox[0][(work>>24)&0x3f];
work=r^kptr[4*i+1];
l^=Spbox[7][(work)&0x3f]
^Spbox[5][(work>>8)&0x3f]
^Spbox[3][(work>>16)&0x3f]
^Spbox[1][(work>>24)&0x3f];
work=rotr(l,4U)^kptr[4*i+2];
r^=Spbox[6][(work)&0x3f]
^Spbox[4][(work>>8)&0x3f]
^Spbox[2][(work>>16)&0x3f]
^Spbox[0][(work>>24)&0x3f];
work=l^kptr[4*i+3];
r^=Spbox[7][(work)&0x3f]
^Spbox[5][(work>>8)&0x3f]
^Spbox[3][(work>>16)&0x3f]
^Spbox[1][(work>>24)&0x3f];
}
FPERM(l,r);
#ifdefIS_LITTLE_ENDIAN
*(word32*)outBlock=byteReverse(r);
*(word32*)(outBlock+4)=byteReverse(l);
#else
*(word32*)outBlock=r;
*(word32*)(outBlock+4)=l;
#endif
}
voidDES_EDE_Encryption::ProcessBlock(byte*inoutBlock)const
{
e.ProcessBlock(inoutBlock);
d.ProcessBlock(inoutBlock);
e.ProcessBlock(inoutBlock);
}
voidDES_EDE_Encryption::ProcessBlock(constbyte*inBlock,byte*outBlock)const
{
e.ProcessBlock(inBlock,outBlock);
d.ProcessBlock(outBlock);
e.ProcessBlock(outBlock);
}
voidDES_EDE_Decryption::ProcessBlock(byte*inoutBlock)const
{
d.ProcessBlock(inoutBlock);
e.ProcessBlock(inoutBlock);
d.ProcessBlock(inoutBlock);
}
voidDES_EDE_Decryption::ProcessBlock(constbyte*inBlock,byte*outBlock)const
{
d.ProcessBlock(inBlock,outBlock);
e.ProcessBlock(outBlock);
d.ProcessBlock(outBlock);
}
voidTripleDES_Encryption::ProcessBlock(byte*inoutBlock)const
{
e1.ProcessBlock(inoutBlock);
d.ProcessBlock(inoutBlock);
e2.ProcessBlock(inoutBlock);
}
voidTripleDES_Encryption::ProcessBlock(constbyte*inBlock,byte*outBlock)const
{
e1.ProcessBlock(inBlock,outBlock);
d.ProcessBlock(outBlock);
e2.ProcessBlock(outBlock);
}
voidTripleDES_Decryption::ProcessBlock(byte*inoutBlock)const
{
d1.ProcessBlock(inoutBlock);
e.ProcessBlock(inoutBlock);
d2.ProcessBlock(inoutBlock);
}
voidTripleDES_Decryption::ProcessBlock(constbyte*inBlock,byte*outBlock)const
{
d1.ProcessBlock(inBlock,outBlock);
e.ProcessBlock(outBlock);
d2.ProcessBlock(outBlock);
}
NAMESPACE_END
程序運行如下: