好久没写过博客啦，最近在gao搞Qt，做出漂亮的UI确实挺难的，做美工也不简单啊，好啦，言归正传，下面是实现DES的python源码，是借鉴了开源中国一个大师的源码写出来的，直接贴啦。
加密部分：
#!/usr/bin/python
#coding:utf-8 from DESstruction import *
import re __all__ = ['desencode'] class DES():
def __init__(self):
pass
#加密
def code(self, former_code, key, code_len, key_len):
output = ""
trun_len = 0 #将密文和密钥转换为二进制
code_string = self.hexTobin(former_code, code_len)
code_key = self.hexTobin(key, key_len) #如果密钥长度不是16的整数倍则以增加0的方式变为16的整数倍
if code_len % 16 != 0:
real_len = (code_len / 16) * 16 + 16
else:
real_len = code_len if key_len % 16 != 0:
key_len = (key_len / 16) * 16 + 16
key_len *= 4 #每个16进制占4位
trun_len = 4 * real_len
#对每64位进行一次加密
for i in range(0, trun_len, 64):
run_code = code_string[i : i+64]
l = i % key_len
run_key = code_key[l : l+64] #64位明文、密钥初始置换
run_code = self.code_Firstchange(run_code)
run_key = self.key_Firstchange(run_key) #16次迭代
for j in range(16): #取出明文左右32位
code_r = run_code[32 : 64]
code_l = run_code[0 : 32] #64左右交换
run_code = code_r #右边32位扩展置换
code_r = self.code_Expand(code_r) #获取本*密钥
key_l = run_key[0:28]
key_r = run_key[28 : 56]
key_l = key_l[d[j] : 28] + key_l[0 : d[j]]
key_r = key_r[d[j] : 28] + key_r[0 : d[j]]
run_key = key_l + key_r
key_y = self.key_Secondchange(run_key) #异或
code_r = self.code_xor(code_r,key_y) #S盒代替/选择
code_r = self.key_Sbox(code_r) #P转换
code_r = self.key_Pbox(code_r) #异或
code_r = self.code_xor(code_l, code_r)
run_code += code_r
#32互换
code_r = run_code[32 : 64]
code_l = run_code[0 : 32]
run_code = code_r + code_l #将二进制转换为16进制、逆初始置换
output += self.code_Inversepermutation(run_code)
return output #将十六进制转换为二进制字符串
def hexTobin(self, code, lens):
new_code = ''
lens = lens % 16
for key in code:
code_ord = int(key,16)
new_code += self.Tobin(code_ord, 4)
if lens != 0:
new_code += '' * (16 - lens) * 4
return new_code #二进制转换
def Tobin(self, o, lens):
new_code = ''
for i in range(lens):
new_code = str(o >> i & 1) + new_code
return new_code #密文或明文初s始置换
def code_Firstchange(self, code):
changed_code = ''
for i in range(64):
changed_code += code[ip[i] - 1]
return changed_code #密钥初始置换
def key_Firstchange (self, key):
changed_key = ''
for i in range(56):
changed_key += key[pc1[i] - 1]
return changed_key #扩展置换
def code_Expand(self, code):
new_list = ''
for i in range(48):
new_list += code[e[i] - 1]
return new_list #密钥置换选择2
def key_Secondchange(self, key):
new_list = ''
for i in range(48):
new_list += key[pc2[i] - 1]
return new_list #异或
def code_xor(self, code, key):
code_len = len(key)
new_list = ''
for i in range(code_len):
if code[i] == key[i]:
new_list += ''
else:
new_list += ''
return new_list #S盒代替选择置换
def key_Sbox(self, key):
new_list = ''
for i in range(8):
row = int(str(key[i * 6]) + str(key[i * 6 + 5]), 2)
raw = int(str(key[i * 6 + 1]) + str(key[i * 6 + 2]) + str(key[i * 6 + 3]) + str(key[i * 6 + 4]), 2)
new_list += self.Tobin(s[i][row][raw], 4) return new_list #置换P
def key_Pbox(self, code):
new_list = ''
for i in range(32):
new_list += code[p[i] - 1]
return new_list #逆初始置换
def code_Inversepermutation(self, code):
lens = len(code) / 4
new_list = ''
for i in range(lens):
list = ''
for j in range(4):
list += code[ip_1[i * 4 + j] - 1]
new_list += "%x" % int(list, 2)
return new_list def DES_encode(former_code,key):
#转换为16进制
former_code = Tohex(former_code)
key = Tohex(key) des = DES()
key_len = len(key)
code_len = len(former_code) if code_len < 1 or key_len < 1:
print 'error input'
return False key_code = des.code(former_code, key, code_len, key_len)
return key_code #将unicode字符转换为16进制
def Tohex(string):
new_string = '' for i in string:
new_string += "%02x" % ord(i) return new_string def tounicode(string):
return_string = ''
string_len = len(string)
for i in range(0, string_len, 2):
return_string += chr(int(string[i : i + 2], 16))
return return_string if __name__ == '__main__':
print DES_encode('12083612isawonder', '0f1571c947刘')
解密方法：
#!/usr/bin/python
#coding:utf-8 from DESstruction import *
import re __all__ = ['desdecode']
class DES(): def __init__(self):
pass
#解密
def decode(self, string, key, key_len, string_len):
output = ""
trun_len = 0
num = 0 #将密文转换为二进制
code_string = self.hexTobin(string, string_len)
#获取字密钥
code_key = self.getKey(key, key_len) #如果密钥长度不是16的整数倍则以增加0的方式变为16的整数倍
real_len = (key_len / 16) + 1 if key_len % 16 != 0 else key_len / 16
trun_len = string_len * 4
#对每64位进行一次加密
for i in range(0, trun_len, 64):
run_code = code_string[i : i + 64]
run_key = code_key[num % real_len] #64位明文初始置换
run_code = self.code_Firstchange(run_code) #16次迭代
for j in range(16): code_r = run_code[32 : 64]
code_l = run_code[0 : 32] #64左右交换
run_code = code_r #右边32位扩展置换
code_r = self.code_Expand(code_r) #获取本*密钥
key_y = run_key[15 - j] #异或
code_r = self.code_xor(code_r, key_y) #S盒代替/选择
code_r = self.code_Sbox(code_r) #P转换
code_r = self.code_Pbox(code_r) #异或
code_r = self.code_xor(code_l,code_r) run_code += code_r
num += 1 #32互换
code_r = run_code[32 : 64]
code_l = run_code[0 : 32]
run_code = code_r + code_l #将二进制转换为16进制、逆初始置换
output += self.code_Inversepermutation(run_code)
return output #将十六进制转换为二进制字符串
def hexTobin(self, code, lens):
return_code = ''
lens = lens % 16
for key in code:
code_ord = int(key,16)
return_code += self.Tobin(code_ord, 4) if lens != 0:
return_code += '' * (16 - lens) * 4
return return_code #获取子密钥
def getKey(self, key, key_len): #将密钥转换为二进制
code_key = self.hexTobin(key, key_len) a = [''] * 16
real_len = (key_len / 16) * 16 + 16 if key_len % 16 != 0 else key_len b = [''] * (real_len / 16)
for i in range(real_len / 16):
b[i] = a[ : ]
num = 0
trun_len = 4 * key_len
for i in range(0, trun_len, 64):
run_key = code_key[i : i + 64]
run_key = self.key_Firstchange(run_key)
for j in range(16):
key_l = run_key[0 : 28]
key_r = run_key[28 : 56]
key_l = key_l[d[j] : 28] + key_l[0 : d[j]]
key_r = key_r[d[j] : 28] + key_r[0 : d[j]]
run_key = key_l + key_r
key_y = self.key_Secondchange(run_key)
b[num][j] = key_y[ : ]
num += 1 return b #密文或明文初始置换
def code_Firstchange(self, code):
changed_code = ''
for i in range(64):
changed_code += code[ip[i] - 1]
return changed_code #扩展置换
def code_Expand(self, code):
return_list = ''
for i in range(48):
return_list += code[e[i] - 1]
return return_list #异或
def code_xor(self, code, key):
code_len = len(key)
return_list = ''
for i in range(code_len):
if code[i] == key[i]:
return_list += ''
else:
return_list += ''
return return_list #二进制转换
def Tobin(self, o, lens):
return_code = ''
for i in range(lens):
return_code = str(o >> i & 1) + return_code
return return_code #S盒代替选择置换
def code_Sbox(self, key):
return_list=''
for i in range(8):
row = int(str(key[i * 6]) + str(key[i * 6 + 5]), 2)
raw = int(str(key[i*6+1]) + str(key[i * 6 + 2]) + str(key[i * 6 + 3]) + str(key[i * 6 + 4]), 2)
return_list += self.Tobin(s[i][row][raw], 4)
return return_list #置换P
def code_Pbox(self, code):
return_list = ''
for i in range(32):
return_list += code[p[i] - 1]
return return_list #密钥初始置换
def key_Firstchange(self, key):
changed_key = ''
for i in range(56):
changed_key += key[pc1[i] - 1]
return changed_key #逆初始置换
def code_Inversepermutation(self, code):
return_list = ''
for i in range(16):
list = ''
for j in range(4):
list += code[ip_1[i * 4 + j] - 1]
return_list += "%x" % int(list, 2)
return return_list #密钥置换选择2
def key_Secondchange(self, key):
return_list = ''
for i in range(48):
return_list += key[pc2[i] - 1]
return return_list #入口函数
def DES_decode(from_code, key):
key = tohex(key) des = DES() key_len = len(key)
string_len = len(from_code)
if string_len % 16 != 0:
return False
if string_len < 1 or key_len < 1:
return False key_code = des.decode(from_code, key, key_len, string_len)
return tounicode(key_code) #将unicode字符转换为16进制
def tohex(string):
return_string = ''
for i in string:
return_string += "%02x" % ord(i)
return return_string def tounicode(string):
return_string = ''
string_len = len(string)
for i in range(0, string_len, 2):
return_string += chr(int(string[i : i + 2], 16))
return return_string #测试
if __name__ == '__main__':
print DES_decode('3530b23e0d9d0f5c2cb2602ac98fd26382ed6769d3dcf00a', '0f1571c947刘')