對稱加密演算法——DES演算法（python實現）
一、DES演算法描述
DES演算法總的說來可以兩部分組成：
1、對金鑰的處理。這一部分是把我們用的64位金鑰（實際用的56位，去掉了8個奇偶校驗位）分散成16個48位的子金鑰。
2、對資料的加密。通過第一步生成的子金鑰來加密我們所要加密的資料，最終生成密文。
下面就通過這兩部分分別介紹DES演算法的實現原理。
1．金鑰分散——子金鑰的生成
64位元的金鑰生成16個48位元的子金鑰。其生成過程見圖：
64位元的金鑰K，經過PC-1後，生成56位元的串。其下標如表所示：
該位元串分為長度相等的位元串C0和D0（分別為28位元）。然後C0和D0分別迴圈左移1位，得到C1和D1。C1和D1合併起來生成C1D1。C1D1經過PC-2變換後即生成48位元的K1。K1的下標列表為：
C1、D1分別迴圈左移LS2位，再合併，經過PC-2，生成子金鑰K2……依次類推直至生成子金鑰K16。
注意：Lsi (I =1,2,….16)的數值是不同的。具體見下表：
注：PC-1 和 PC-2是金鑰的指定為置換。
至此，我們已成功的生成了16個48位的子金鑰。
2．加密流程圖
DES演算法處理的資料物件是一組64位元的明文串。設該明文串為m=m1m2…m64(mi=0或1)。明文串經過64位元的金鑰K來加密，最後生成長度為64位元的密文E。其加密過程圖示如下：
3． DES演算法加密過程
對DES演算法加密過程圖示的說明如下：待加密的64位元明文串m，經過IP置換後，得到的位元串的下標列表如下：
該位元串被分為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後生成的位元串就是密文e.。
f 演算法
變換f(Ri-1,Ki)的功能是將32位元的輸入再轉化為32位元的輸出。其過程如圖所示：
首先、輸入Ri-1(32位元)經過變換E後，膨脹為48位元。膨脹後的位元串的下標列表如下：
其次、膨脹後的E和Ki異或的結果分為8組，每組6位元。各組經過各自的S盒後，變為4位元，
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盒的輸出。
最後、合併8組S盒輸出成為32位元。該32位元經過P變換後，其下標列表如下：
經過P變換後輸出的位元串才是32位元的f (Ri-1,Ki)。
以上介紹了DES演算法的加密過程。DES演算法的解密過程是一樣的，區別僅僅在於第一次迭代時用子金鑰K16，第二次K15、......，最後一次用K1，演算法本身並沒有任何變化。
二、目前使用的DES演算法
對於服務端apache，裡面描述的DES加解密，只是最基本、最原始的加解密，而現在很多地方使用的DES都會有一些擴充套件。
接來說下我們目前使用的DES的加解密的使用。
函式des3_set_3keys設定key，如果是3DES，則需要設定3個key，這裡說的key其實就是8位元組的陣列型別的金鑰；
而 函式des3_encrypt是處理的加密，void des3_encrypt( des3_context *ctx, uint8 input[8], uint8output[8] )，其中的input和output分別表示需要加密的和加密後的資料。這裡提供的是8個位元組的資料，如果要加密的資料比8個位元組要長，則需要迴圈使用這 個加密函式；而輸出output，每次呼叫des3_encrypt，輸出都是8位。比如說，需要加密的資料是個10位元組長的數，那麼加完密之後則是16 位。
三、DES演算法的兩種模式
上面描述的只是是最基本的DES加密，而通常外界使用的DES很多都有模式以及填充方式的設定，如果設定不一樣，將會導致一些介面資訊不一致，加解密的資料就對不上。
比較常用的模式有：cbc和ecb。
這裡主要介紹DES演算法的資料補位問題、DES演算法的兩種模式ECB和CBC問題，以及更加安全的演算法3DES。
1、資料補位
DES資料加解密就是將資料按照8個位元組一段進行DES加密或解密得到一段8個位元組的密文或者明文，最後一段不足8個位元組，按照需求補足8個位元組（通常補00或者FF，根據實際要求不同）進行計算，之後按照順序將計算所得的資料連在一起即可。
很多地方預設的補位方式是以PKCS7補位的，如果C#預設的就是PKCS7補位：補位補到8位的整數倍，差幾位補幾。
這裡有個問題就是為什麼要進行資料補位？主要原因是DES演算法加解密時要求資料必須為8個位元組。
2、ECB模式
DES ECB（電子密本方式）其實非常簡單，就是將資料按照8個位元組一段進行DES加密或解密得到一段8個位元組的密文或者明文，最後一段不足8個位元組，按照需求補足8個位元組進行計算，之後按照順序將計算所得的資料連在一起即可，各段資料之間互不影響。
3、CBC模式
DES CBC（密文分組連結方式）有點麻煩，它的實現機制使加密的各段資料之間有了聯絡。其實現的機理如下：
加密步驟如下：
1）首先將資料按照8個位元組一組進行分組得到D1D2......Dn（若資料不是8的整數倍，用指定的PADDING資料補位）
2）第一組資料D1與初始化向量I異或後的結果進行DES加密得到第一組密文C1（初始化向量I為全零）
3）第二組資料D2與第一組的加密結果C1異或以後的結果進行DES加密，得到第二組密文C2
4）之後的資料以此類推，得到Cn
5）按順序連為C1C2C3......Cn即為加密結果。
解密是加密的逆過程，步驟如下：
1）首先將資料按照8個位元組一組進行分組得到C1C2C3......Cn
2）將第一組資料進行解密後與初始化向量I進行異或得到第一組明文D1（注意：一定是先解密再異或）
3）將第二組資料C2進行解密後與第一組密文資料進行異或得到第二組資料D2
4）之後依此類推，得到Dn
5）按順序連為D1D2D3......Dn即為解密結果。
python實現：
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# 2014/10/16 wrote by yangyongzhen
# QQ:534117529
# global definition
# base = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F]
__author__ = 'YangYongZhen'
base = [str(x) for x in range(10)] + [ chr(x) for x in range(ord('A'),ord('A')+6)]
# bin2dec
# 二進位制 to 十進位制: int(str,n=10)
def bin2dec(string_num):
return str(int(string_num, 2))
# hex2dec
# 十六進位制 to 十進位制
def hex2dec(string_num):
return str(int(string_num.upper(), 16))
# dec2bin
# 十進位制 to 二進位制: bin()
def dec2bin(string_num):
num = int(string_num)
mid = []
while True:
if num == 0: break
num,rem = divmod(num, 2)
mid.append(base[rem])
return ''.join([str(x) for x in mid[::-1]])
# dec2hex
# 十進位制 to 八進位制: oct()
# 十進位制 to 十六進位制: hex()
def dec2hex(string_num):
num = int(string_num)
if num==0:
return '0'
mid = []
while True:
if num == 0: break
num,rem = divmod(num, 16)
mid.append(base[rem])
return ''.join([str(x) for x in mid[::-1]])
# hex2tobin
# 十六進位制 to 二進位制: bin(int(str,16))
def hex2bin(string_num):
return dec2bin(hex2dec(string_num.upper()))
# bin2hex
# 二進位制 to 十六進位制: hex(int(str,2))
def bin2hex(string_num):
return dec2hex(bin2dec(string_num))
'''
/**
* PBOC3DES 加密演算法
* @author Administrator
*
*/
'''
class PBOC_DES():
pass
'''
/** ***************************壓縮替換S-Box************************************************* */
'''
subKey = [([0] * 48) for ll in range(16)]
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 ] ]
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 ]
_ip = [ 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 ]
# 每次金鑰迴圈左移位數
LS = [ 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2,2, 1 ]
'''
/**
* IP初始置換
* @param source
* @return
*/
'''
def changeIP(source):
dest= [0]*64
global ip
for i in range(64):
dest[i] = source[ip[i] - 1]
return dest
def string2Binary(str):
le = len(str)
dest =[0]*le*4
i = 0
for c in str:
i += 4
j = 0
s = hex2bin(c)
l = len(s)
for d in s:
dest[i-l+j]=int(d)
j += 1
return dest
'''
/**
* IP-1逆置
* @param source
* @return
*/
'''
def changeInverseIP(source):
dest = [0]*64
global _ip
for i in range(64):
dest[i] = source[_ip[i] - 1]
return dest
'''
/**
*
* 獲取輪子金鑰(48bit)
*
* @param source
*
* @return
*
*/
'''
def setKey(source):
global subKey
# 裝換4bit
temp = string2Binary(source)
# 6bit均分成兩部分
left = [0]*28
right = [0]*28
# 經過PC-14bit轉換6bit
temp1 = [0]*56
temp1 = keyPC_1(temp)
# printArr(temp1);
#將經過轉換的temp1均分成兩部分
for i in range(28):
left[i] = temp1[i]
right[i] = temp1[i + 28]
# 經過16次迴圈左移，然後PC-2置換
for i in range(16):
left = keyLeftMove(left, LS[i])
right = keyLeftMove(right, LS[i])
for j in range(28):
temp1[j] = left[j]
temp1[j + 28] = right[j]
subKey[i] = keyPC_2(temp1)
'''
/**
*
* 6bit的金鑰轉換成48bit
* @param source
* @return
*
*/
'''
def keyPC_2(source):
dest = [0]*48
temp = [ 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 i in range(48):
dest[i] = source[temp[i] - 1]
return dest
'''
/**
*
* 將金鑰迴圈左移i
* @param source 二進位制金鑰數
* @param i 迴圈左移位數
* @return
*
*/
'''
def keyLeftMove( source, i):
temp = 0
global LS
le = len(source)
ls = LS[i]
for k in range(ls):
temp = source[0]
for j in range(le-1):
source[j] = source[j + 1]
source[le - 1] = temp
return source
'''
/**
*
* 4bit的金鑰轉換成56bit
* @param source
* @return
*
*/
'''
def keyPC_1(source):
dest = [0]*56
temp = [ 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 ]
for i in range(56):
dest[i] = source[temp[i] - 1]
return dest
'''
/**
* 兩個等長的陣列做異或
* @param source1
* @param source2
* @return
*/
'''
def diffOr( source1, source2):
le = len(source1)
dest = [0]*le
for i in range(le):
dest[i] = source1[i] ^ source2[i]
return dest
'''
/**
*
* DES加密--->對稱金鑰
* D = Ln(32bit)+Rn(32bit)
* 經過16輪置
* @param D(16byte)明文
* @param K(16byte)輪子金鑰
* @return (16byte)密文
*/
'''
def encryption( D, K) :
temp = [0]*64;
data = string2Binary(D)
# 第一步初始置
data = changeIP(data)
left = [([0] * 32) for i in range(17)]
right = [([0] * 32) for i in range(17)]
for j in range(32):
left[0][j] = data[j]
right[0][j] = data[j + 32]
setKey(K)# sub key ok
for i in range(1,17):
# 獲取(48bit)的輪子密
key = subKey[i - 1]
# L1 = R0
left[i] = right[i - 1]
# R1 = L0 ^ f(R0,K1)
fTemp = f(right[i - 1], key)# 32bit
right[i] = diffOr(left[i - 1], fTemp)
#組合的時候，左右調換
for i in range(32):
temp[i] = right[16][i]
temp[32 + i] = left[16][i]
temp = changeInverseIP(temp)
str = binary2ASC(intArr2Str(temp))
return str
'''
/**
* 8bit壓縮2bit
* @param source(48bit)
* @return R(32bit) B=E(R)⊕K，將48 位的B 分成8 個分組，B=B1B2B3B4B5B6B7B8
*/
'''
def press(source) :
ret = [0]*32
temp = [([0] * 6) for i in range(8)]
s =[s1,s2,s3,s4,s5,s6,s7,s8]
st=[]
for i in range(8):
for j in range(6):
temp[i][j] = source[i * 6 + j]
for i in range(8):
# (16)
x = temp[i][0] * 2 + temp[i][5]
# (2345)
y = temp[i][1] * 8 + temp[i][2] * 4 + temp[i][3] * 2+ temp[i][4]
val = s[i][x][y]
ch = dec2hex(str(val))
# System.out.println("x=" + x + ",y=" + y + "-->" + ch);
# String ch = Integer.toBinaryString(val);
st.append(ch)
# System.out.println(str.toString());
ret = string2Binary(st)
# printArr(ret);
# 置換P
ret = dataP(ret)
return ret
'''
/**
* 置換P(32bit)
* @param source
* @return
*/
'''
def dataP( source):
dest = [0]*32
temp = [ 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 ]
le = len(source)
for i in range(le):
dest[i] = source[temp[i] - 1]
return dest
'''
/**
* 2bit擴充套件8bit
* @param source
* @return
*/
'''
def expend(source):
ret = [0]*48
temp = [ 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 ]
for i in range(48):
ret[i] = source[temp[i] - 1]
return ret
'''
/**
* @param R(2bit)
* @param K(48bit的輪子密
* @return 32bit
*/
'''
def f( R, K):
dest = [0]*32
temp = [0]*48
# 先將輸入32bit擴充套件8bit
expendR = expend(R)# 48bit
# 與輪子金鑰進行異或運
temp = diffOr(expendR, K);
# 壓縮2bit
dest = press(temp)
return dest
'''
/**
* 將int型別陣列拼接成字串
* @param arr
* @return
*/
'''
def intArr2Str( arr) :
sb = []
le=len(arr)
for i in range(le):
sb.append(str(arr[i]))
return ''.join(sb)
'''
/**
* 將二進位制字串轉換成十六進位制字元
* @param s
* @return
*/
'''
def binary2ASC(s):
st = ''
ii = 0
le= len(s)
#不夠4bit左補0
if le % 4 != 0:
while ii < (4 - len % 4):
s = "0" + s
le=le/4
for i in range(le):
st += bin2hex(s[i * 4 : i * 4 + 4])
return st
if __name__=="__main__":
D='1111111111111111'
K='FFFFFFFFFFFFFFFF'
print encryption(D,K)