密码的加密

一、绪论

本章是全篇的绪论部分，首先描述了 DES 算法的整体研究背景并论述了加密技术的重大意义;其次在阅览大量中英文文献后针对当前国内外对于 DES 应用的研究现状做了综述;最后概括性地总结了本文的主要研究工作以及全篇的结构安排。

二、研究背景及意义

随着信息与通信技术的迅猛发展和广泛应用,网络与信息系统基础性、全局性的作用日益增强, 人们通过互联网进行信息交流，难免涉及到密码保护问题，这不仅关系到个人隐私甚至可能是国家机密，国家安全。隐私与机密网络信息的安全与保护问题日益成为亟待解决的关键问题。从这个意义上来说，提出一种对密码的有效加密算法，就是我们必须面对的问题，但是密码的复杂性和无序性给加密算法的设计带来难题，于是，我们必须寻找一种对简单密码普遍适用的规律性算法，那么，对对称密码的加密就成为最实用最普遍的问题。随着中国经济，社会的发展与崛起，生活的便捷性与快捷性越来越深入人心，网上购物，网上交易会越来越频繁，藉此，密码安全就成为我们最关注的问题。对密码的保护就成为我们的共识与需求，而加密最能体现出它的分量，那对对称

密码的加密同样就有深远的研究价值与现实意义。

不仅国内，国外对数据加密同样重视，1977 年，美国数据加密标准（Data Encryption Standard, DES)颁布，在此后的 30 年，DES 成为世界范围内的标准，，相关算法的不断改进，和新方法，新思路的不断涌现，这些，对对称密码加密算法的深入研究都起到很大的作用。

三、国内外相关研究现状及发展趋势

国外目前不仅在密码基础理论方面的研究做的很好，而且在实际应用方面也做的非常好。制定了一系列特别规范的密码标准。尽管算法的征集和讨论都已经公开化，但密码技术作为一种关键技术，各国都不会放弃自主权和控制权，争夺霸权地位。

目前国际上对非数学的密码理论与技术非常关注，讨论也非常活跃。信息隐藏将在未来网络中保护信息免于破坏起到重要作用，信息隐藏是网络环境下把机密信息隐藏在大量信息中不让对方发觉的一种方法。特别是图象叠加、数字水印、潜信道、隐匿协议等的理论与技术的研究已经引起人们的重视。1996 年以来，国际上召开了多次有关信息隐藏的专业研讨会。基于生物特征的识别理论与技术已有所发展，形成了一些理论和技术，也形成了一些产品。

四、全文内容安排

本文由六个章节构成，全文安排如下:

第一章，绪论。主要通过一些数据，强调研究背景及意义的重要性，介绍国内外的关键技术研究现状。在互联网时代，加密算法对于维护国家安全、维护社会和平发展有着举足轻重的作用。

第二章，DES 算法原理。首先是对本文所使用的 DES 技术进行介绍，然后介绍了本文中所涉及的工作原理和 3DES 算法。

第三章，基于 3DES 的图片加密程序具体实现。首先介绍了图片数据的处理及分组实现，然后针对组内加密和 CBC 分组运行模式，详细地举例并阐释了程序的运行原理，最后通过密文图像显示和解密验证了方法的可行性，给出了最终的实验结果。

第四章，列出在程序编写过程中所遇到的问题并给出自己的解决思路。

第五章，实验数据，给出程序最终运行时所产生的加解密文件和运行效果图。

第六章，总结。对本文所做的研究工作做了概括总结。

第七章，给出整个程序的代码实现。

第八章，给出程序撰写中所引用的参考文献。

五、DES 算法原理

在第一章绪论中介绍了本文的研究背景、选题意义，了解到随着互联网的飞速发展，加密算法在扮演着越来越举足轻重的作用，故逐渐成为政府机构和研究学者们关注的热点问题，本章对 DES 算法的基本原理做深入探索和研究。

六、DES 简介

DES 全称叫(Data Encryption Standard), 是 1977 年美国联邦信息处理标准（FIPS）中所采用的一种对称加密算法。DES 之前一直使用很普遍，但是随着计算机的进步，现在 DES 已经可以被暴力破解了，除研究的原因外，我们不再建议使用 DES 算法。

七、DES 的加密解密

DES 的密钥长度是 64 比特，也就是 8 个字节。但是 DES 每隔 7 比特会设置一个错误校验位，所以真正的密钥长度是 56 比特。

因为 DES 的长度是 64 比特，每次只能将长度为 64 比特的原文进行加密，如果原文长于 64 比特的话，需要多次分组进行加密，这 64 比特的单位也叫做分组。

八、DES 工作原理

DES 由 Horst Feistel 设计，也称作 Feistel 网络。Feistel 网络，加密的各个步骤称为轮（round)，整个加密过程就是进行若干轮的循环。

下图展示了 DES 中的一轮加密过程：

九、图 2-1 DES 加密过程

在每一轮的操作中，输入的数据被分成左右两部分，中间的子密钥指本轮加密所使用的密钥。在 Feistel 网络中，每一轮都使用不同的密钥，该密钥只是一个局部密钥，所以被称为子密钥。

其运算步骤如下：

将输入的数据分成左右两部分

将输入的右边直接发送到输出的右边

将输入的右边发送到轮函数 f

轮函数根据右侧数据和子密钥计算出一个随机数

将 4 得到的随机数和左侧数据进行 XOR 运算，将运算后的结果作为加密的左侧。

这一轮操作，只加密了左侧数据，右侧的没有加密，交换左右两侧的数据，再来一轮加密。这样右侧的数据也被加密。

十、DES 解密原理

XOR 的特性，即： A XOR B = C C XOR B = A

按照这样的特性，我们只需要将加密后的结果跟步骤 4 中计算出来的随机数再做一次 XOR 运算即可还原加密前的数据。

如下图所示：

十一、图 2-2 DES 解密过程

十二、三重 DES

三重 DES 是为了增加 DES 的强度，将 DES 重复 3 次所得到的一种密码算法，通常缩写为 3DES。

读入图片的二进制流

使用 rb 方式读入二进制 byte 流

c++ file=open(cwd,'rb')

字符串转二进制 bit

该算法逐字读入 byte 将其转换为二进制形式 bit

通过类似 8 进制转 2 进制的方法将以字节为单位占据 8 位的字节流转换为以比特为单位的占据 1 位的 01 比特

``` __String_to_BitList(self, data): """Turn the string data, into a list of bits (1, 0)'s""" if _pythonMajorVersion < 3: # Turn the strings into integers. Python 3 uses a bytes # class, which already has this behaviour. data = [ord(c) for c in data] l = len(data) * 8 result = [0] * l pos = 0 for ch in data: i = 7 while i >= 0: if ch & (1 << i) != 0: result[pos] = 1 else: result[pos] = 0 pos += 1 i -= 1

```

十八、des 填充及分组

填充：

des 算法使用 64 位为单位的数据流，读入的图片数据要先经过数据的填充和切分使之符合要求。

``` if len(data) % self.block_size != 0: if crypt_type == des.DECRYPT: # Decryption must work on 8 byte blocks raise ValueError("Invalid data length, data must be a multipl e of " + str(self.block_size) + " bytes\n.") if not self.getPadding(): raise ValueError("Invalid data length, data must be a multipl e of " + str(self.block_size) + " bytes\n. Try setting the optional padding character") else: data += (self.block_size – (len(data) % self.block_size)) * self.getPadding() # print "Len of data: %f" % (len(data) / self.block_size)

```

该部分代码检查传入数据是否符合规则，若解密模式传入错误长度密文则报错

否则为其填充 len(data)/self.block_size 个 pad 字符，默认为空，此为第一次数据的补位。

CBC 模式下的补位不能直接补空或 0，需要一个初始的填充值，该值需要我们自己手动给出并且 01 比特化

``` if self.getMode() == CBC: if self.getIV(): iv = self.__String_to_BitList(self.getIV()) else: raise ValueError("For CBC mode, you must supply the Initial V alue (IV) for ciphering")

```

分组：

该段程序将数据流拆成 8 字节即 64 位，每段数据分别 01 比特化后检验，

若是 CBC 模式，将源数据按位与给出的初始补充数据异或实现将上下文连接起来增强安全性的 CBC 功能，之后将预处理好的 64 位数据送往 DES 加密。

``` while i < len(data):

        block = self.__String_to_BitList(data[i:i+8])
        if self.getMode() == CBC:
            if crypt_type == des.ENCRYPT:
                block = list(map(lambda x, y: x ^ y, block, iv))

            processed_block = self.__des_crypt(block, crypt_type)

            if crypt_type == des.DECRYPT:
                processed_block = list(map(lambda x, y: x ^ y, 
                                                processed_block, iv))
                iv = block
            else:
                iv = processed_block
        else:
            processed_block = self.__des_crypt(block, crypt_type)

```

十九、组内加密

本实验使用 3des 加解密方式，该算法与 des 不同之处在于，需要给出 3 个 8 字节密钥或者一次给出 24 字节密钥，通过加密-解密-加密三次不同密钥的普通 des 加密获得比普通加密更高的安全性。

二十、密钥拆分

该段代码实现：检查密钥长度并在不符合要求的情况下弹出提示，将 24 字节密钥拆分为三段密钥，最后连续进行三次 des 算法。特别指出的是，本算法同样接收 16 字节长度的密钥，在这种情况下，3des 算法退化为 des 算法。

当模式为 CBC 且没有指定初始补充数据时，初始补充数据为密钥的前 8 字节

``` def setKey(self, key): self.key_size = 24 # Use DES-EDE3 mode if len(key) != self.key_size: if len(key) == 16: # Use DES-EDE2 mode self.key_size = 16 else: raise ValueError("Invalid triple DES key size. Key must be ei ther 16 or 24 bytes long") if self.getMode() == CBC: if not self.getIV(): # Use the first 8 bytes of the key self._iv = key[:self.block_size] if len(self.getIV()) != self.block_size: raise ValueError("Invalid IV, must be 8 bytes in length") self.__key1 = des(key[:8], self._mode, self._iv, self._padding, self._padmode) self.__key2 = des(key[8:16], self._mode, self._iv, self._padding, self._padmode) if self.key_size == 16: self.__key3 = self.__key1 else: self.__key3 = des(key[16:], self._mode, self._iv, self._padding, self._padmode) _baseDes.setKey(self, key)

```

DES 初始化

该段代码传入一些关键信息包括密钥，初始补充数据，填充模式等同时声明了一些运算所必须的容器包括左右数组，16 个子密钥等。

``` def init (self, key, mode=ECB, IV=None, pad=None, padmode=PAD_NORMAL): # Sanity checking of arguments. if len(key) != 8: raise ValueError("Invalid DES key size. Key must be exactly 8 bytes long.") _baseDes. init (self, mode, IV, pad, padmode) self.key_size = 8

    self.L = []
    self.R = []
    self.Kn = [ [0] * 48 ] * 16 # 16 48-bit keys (K1 - K16)
    self.final = []

    self.setKey(key)

```

密钥置换

映射函数，定义了一个建立子密钥到某个列表的映射

def__permutate(self,table,block):

"""Permutatethisblockwiththespecifiedtable"""

returnlist(map(lambdax:block[x],table))

该段代码调用映射函数，实现了密钥的 pc1 变换，该步骤后密钥变为 56 位

key=self.__permutate(des.__pc1,self.__String_to_BitList(self.getKey()))

pc1 表

将 56 位密钥分为左边和右边两部分，对该 28 位，进行按照左移表的重复左移。

``` self.L = key[:28] self.R = key[28:] while i < 16: j = 0 # Perform circular left shifts while j < des.__left_rotations[i]: self.L.append(self.L[0]) del self.L[0]

            self.R.append(self.R[0])
            del self.R[0]
            j += 1

```

图 3-2 左移表

类似 pc1 变换地，调用映射函数并进行 pc2 变换

self.Kn[i]=self.__permutate(des.__pc2,self.L+self.R)

图 3-3 pc2 表

通过上述操作，我们就得到了 16 组 48 位的子密钥

图 3-4 子密钥产生图

ip 盒置换

IP 置换的目的是将转化后的 64 位比特数据按位重新组合，并把输出分为 L0 和 R0 两部分，各部分长 32 位。例如 ip 盒中的第一个数是 57，那么就是把原数据中的第 57 位放到新数据的第 1 位

block=self.__permutate(des.__ip,block)

self.L=block[:32]

self.R=block[32:]

图 3-5 IP 盒

轮函数 f 迭代

有了每一轮的加密密钥 Ki，就可以进行 16 次迭代

图 2-6 f 函数迭代过程

根据加密或是解密确定运算方向

ifcrypt_type==des.ENCRYPT: iteration=0 iteration_adjustment=1 #DecryptionstartsfromKn[16]downtoKn[1] else: iteration=15 iteration_adjustment=-1

E 扩展置换

实现明文拓展的功能，使用 E 盒将明文的部分 bit 重复排列，造成冗余，来实现拓展。E 扩展置换的目的有两个：

生成与密钥相同长度的数据以进行异或运算

提供更长的结果，再后续的替代运算中可以进行压缩。

self.R=self.__permutate(des.__expansion_table,self.R)

图 3-7 E 扩展盒

子密钥异或，将结果存储到创建的容器 B 中

self.R=list(map(lambdax,y:x^y,self.R,self.Kn[iteration]))

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:]]

S 盒代替

异或运算结束后需要将 48bit 缩减为 32bit，分组使用 S 盒置换。替代由 8 个不同的 S 盒完成，每个 S 盒有 6 个输入 4 个输出。48 位输入分为 8 个 6 位分组，每个分组对应一个 S 盒，对应的 S 盒对各组进行代替操作。替代过程中产生的 8 个 4 位的分组，组合在一起形成 32 位数据

j=0

Bn=[0]*32

pos=0

whilej<8:

m=(B[j][0]<<1)+B[j][5]

n=(B[j][1]<<3)+(B[j][2]<<2)+(B[j][3]<<1)+B[j][4

v=des.__sbox[j][(m<<4)+n]

Bn[pos]=(v&8)>>3

Bn[pos+1]=(v&4)>>2

Bn[pos+2]=(v&2)>>1

Bn[pos+3]=v&1

pos+=4

j+=1

例如 S 盒 8 的输入为 110011，第 1 位和第 6 位组合为 11，对应 S 盒 8 的第 3 行，第 2 位到第 5 位为 1001，对应于 S 盒 8 的地 9 列。S 盒的第 3 行第 9 列的数字为 12，那么就用 1100 来代替 110011。

图 3-8 S 盒

P 盒运算

将 B[1]到 B[8]的串联进行排列组合

self.R=self.__permutate(des.__p,Bn)

图 3-9 P 盒

明文右侧与子密钥进行轮函数 f 后的结果与明文左边的数据进行 xor 运算，然后交换左边和右边

self.R=list(map(lambdax,y:x^y,self.R,self.L))

self.L=tempR

至此我们完成了一轮的 Feistel 变换，如此变换 16 轮，特殊地，在进行最后一轮 Feistel 变换的时候不需要交换左边和右边

IP 逆置换

得到了加密后的 56 位比特后用初始置换函数的逆函数，得到正确的密文序列。

self.final=self.__permutate(des.__fp,self.R+self.L)

returnself.final

图 3-10 fp 盒

至此，一次 DES 组内加密结束。

CBC 分组运行模式

CBC 即 CipherBlockChaining，密码分组链接模式，这种模式是先将明文切分成若干小段，然后每一小段与初始块(IV)或者上一段的密文段进行异或，再与密钥进行加密。

数据的预处理

该段代码分别生成三个对应 3des 的 3 次加解密部分的对象，该对象将被初始化函数赋予包括密钥，加密模式（CBC），IV 初始块，填充字符，填充模式（PKCS5）的信息。

``` self. key1 = des(key[:8], self._mode, self._iv, self._padding, self._padmode) self.__key2 = des(key[8:16], self._mode, self._iv, self._padding, self._padmode) if self.key_size == 16: self.__key3 = self.__key1 该部分代码为初始化函数，赋予对象信息 def __init (self, mode=ECB, IV=None, pad=None, padmode=PAD_NORMAL): if IV: IV = self._guardAgainstUnicode(IV) if pad: pad = self._guardAgainstUnicode(pad) self.block_size = 8 # Sanity checking of arguments. if pad and padmode == PAD_PKCS5: raise ValueError("Cannot use a pad character with PAD_PKCS5") if IV and len(IV) != self.block_size: raise ValueError("Invalid Initial Value (IV), must be a multiple of " + str(self.block_size) + " bytes")

    # Set the passed in variables
    self._mode = mode
    self._iv = IV
    self._padding = pad
    self._padmode = padmode
def _guardAgainstUnicode(self, data):
    if _pythonMajorVersion < 3:
        if isinstance(data, unicode):
            raise ValueError("can only work with bytes, not Unicode strings.")
    else:
        if isinstance(data, str):
            try:
                return data.encode('ascii')
            except UnicodeEncodeError:
                pass
            raise ValueError("can only work with encoded strings, not Unicode.")
    return data

```

CBC 代码

CBC 的每第一小段需要初始值来异或，该段代码确保对象拥有初始值

self.__key1.setIV(self.getIV())

self.__key2.setIV(self.getIV())

self.__key3.setIV(self.getIV())

该段代码搭建一个单元为 8 位比特的循环，一个循环中对该 8 比特数据连续进行三次 des 操作实现 3des，同时每次循环结束后重新对 IV 进行赋值，确保下一次操作以当前数据为参数异或，实现 CBC 模式。

``` i = 0 result = [] while i < len(data): iv = data[i:i+8] block = self.__key3.crypt(iv, DECRYPT) block = self.__key2.crypt(block, ENCRYPT) block = self.__key1.crypt(block, DECRYPT) self.__key1.setIV(iv) self.__key2.setIV(iv) self.__key3.setIV(iv) result.append(block) i += 8

if self.getMode() == CBC: if crypt_type == des.ENCRYPT: block = list(map(lambda x, y: x ^ y, block, iv))

```

密文图像显示

由于图片数据在经过 3des 加密之后原有的文件头尾和数据结构被打乱，无法使用正常的方式读取，我们需要重新开发一个程序将乱码的图片展示。

图 3-11 格式完好的图片

图 3-12 加密后的图片结构，可以看出失去了文件头

该段代码实现了将二进制数据转换为图片的功能

首先获取二进制数据的长度将其换算为将要生成的图片的长和宽，之后通过一个二重循环遍历全部数据，向图片中插入算法计算出的各色像素点，从而实现功能。

``` def bin2img(data, isgrey): colorfunc = calcgrayshade if isgrey else calccolor xsize, ysize = size = determine_size(data) img = Image.new("RGB", size, color=(255, 255, 255, 0)) draw = ImageDraw.Draw(img) try: i = 0 for y in range(ysize): for x in range(xsize): draw.point((x, y), fill=colorfunc(data[i])) i += 1 except IndexError: pass

```

图 3-13 算法生成的图片

密文图像解密

3des 算法的解密基本上是加密的逆运算

CBC 分组组合阶段

从原本的 EN——DE——EN 变为 DE——EN——DE

iv=data[i:i+8]

block=self.__key3.crypt(iv,DECRYPT)

block=self.__key2.crypt(block,ENCRYPT)

block=self.__key1.crypt(block,DECRYPT)

子密钥运算阶段

从加密的 iteration0-15 变为 iteration15-0，相当于 p 盒，f 轮函数，S 盒，E 扩展盒等都是反向运算的。

ifcrypt_type==des.ENCRYPT:

iteration=0

iteration_adjustment=1

else:

iteration=15

iteration_adjustment=-1

图 3-14 解密后的图片数据，与加密前一致

主函数编写

将 3des 算法和二进制转图片算法整合到一个主函数中并为其包装位=为图形处理界面。

该段代码创建图形界面幕布并给出初始值和密钥

python root=Tk() root.geometry("400x400") root.title("刘世卓8003119050图像加解密") ivInt=bytearray("AStringOfIV=","utf-8")#key1 keyInt=bytearray("liushizhuotailihailebahahahahaha","utf-8")#key2

该段代码引用编写的 3des 算法并包装成为函数同时给出命令行的提示，给出按钮在幕布的位置

``` defencrypt_image():

withopen('image.png','rb')asf:

jpgdata=f.read()

k=triple_des(base64.b64decode(keyInt),mode=CBC,IV=base64.b64decode(ivInt),pad=None,padmode=PAD_PKCS5)#encryption

print("pleasewaitforamoment")

jpgdata=k.encrypt(jpgdata)

withopen('Encrypted','wb')asf:

f.write(jpgdata)

print("EncryptionComplete")

b=Button(root,text="Encrypt",command=encrypt_image)

place(x=100,y=210)

defdecrypt_image():

withopen('Encrypted','rb')asf:

jpgdata=f.read()

k=triple_des(base64.b64decode(keyInt),mode=CBC,IV=base64.b64decode(ivInt),padmode=PAD_PKCS5)#decryption

print("pleasewaitforamoment")

jpgdata=k.decrypt(jpgdata)

withopen('Decrypted.png','wb')asf:

f.write(jpgdata)

print("DecryptionComplete")

b=Button(root,text="Decrypt",command=decrypt_image)

place(x=200,y=210) ```

该段代码实现了两个查看图片的按钮和退出按钮，一个查看解密后的图片，一个调用二进制转图片算法，查看加密后的图片。

defcheck_image(): bin2img.it() img=Image.open('Encrypted.png') plt.imshow(img) plt.show() b=Button(root,text="checkdecryimg",command=check_image) place(x=300,y=210) defcheck_image1(): img=Image.open('image.png') plt.imshow(img) plt.show() b=Button(root,text="checkimg",command=check_image1) place(x=300,y=110) exit_button=Button(root,text="Exit",command=root.quit) exit_button.place(x=310,y=310)

图 3-15 实现的图形化界面

问题处理

本次大作业实现了利用 3des 加解密图片功能的程序并为其添加了图形化操作界面，开发过程中遇到了许多问题与挑战，以下是解决它们的思路。

des 算法的精度问题

使用 C++ 语言实现的第一版 des 算法可能某个函数的底层逻辑精度较差，总是在多次连续加解密的过程中丢失信息导致无法将信息还原，在多次代码审计无果后痛下决心使用 python 语言重构，终于获得了较好的加解密效果。

3des 算法的构造问题

3des 算法本身并不复杂，只是 des 以不同密钥对同一段目标数据运行三次罢了。但如果仅仅是对一整个目标数据使用三次 des 算法整个程序就显得十分臃肿而丧失了编程的优雅。最终选择了以 64 比特为一段运行程序，这样的代码在优化运行速度的同时给予 CBC 模式的编写以便利。

CBC 模式的实现问题

类似 3des 算法，解决思路主要是将数据拆成小块并标记，在每次运行主要加解密模块之前将其与上一次的数据依照标记所示进行异或达到目的。

加密图片的显示问题

图片数据在进行加密后文件头尾和其数据结构被完全破坏，常规的图片读取手段无法查看图片，于是选择另外编写一个显示图片的算法。

实验数据

图形化操作界面

加解密提示

生成的加密文件

由一个 image 生成的加密中图片和解密后图片

查看图片功能

查看加密图片功能

总结

在这次实验中,我全心全意地投入到 3des 加解密实现的乐趣和挑战当中。通过查阅资料，学习基础知识和原理架构，遇到问题及时解决，持续不断地尝试探索，我在其实现方面有了全新的认识和突破。

在此次实验前，我对 3des 的认识和了解还只是单纯地停留在老师课堂上所讲的理论基础，可以说是一知半解；但通过此次实验的完整过程，我更加深入地理解和体会了 3des 算法的工作原理，同时在实现程序过程中更加深入的理解了许多相关函数的底层逻辑，也更加熟练地掌握了程序编写所需要遵守的架构和体系，增强了我的编写能力。