Go-Des和3Des算法详解与代码

雨点打透心脏的1/2处 2022-10-17 14:00 167阅读 0赞

**目录**

Des

发展史

分组密码算法设计思想

Des概述

初始置换与逆置换

Feistel结构

轮函数F

E扩展

密钥加

S盒代换

P置换

密钥编排

3Des

优缺点

分组模式

CBC

CFB

OFB

Des的Go实现

明文填充

加密

解密

结果截图

参考

--------------------

# Des #

## 发展史 ##

*  1973年5月美国联邦政府提出征求**在传输和存储数据中保护计算机数据**的密码算法的建议；
 *  1975年3月，美国国家标准局（NBS）首次公布IBM公司提出的算法Lucifer中选；
 *  1977年1月NBS正式向社会公布，采纳IBM公司设计的方案作为非机密数据的数据加密标准（**Data Encryption Standard**)，DES正式成为美国联邦政府信息处理标准，即FIPS-46标准，同年7月开始生效。
 *      此后，每隔5年美国国家保密局（NSA）对DES作新的评估，并重新审定它是否继续作为联邦加密标准。

## 分组密码算法设计思想 ##

1.   如果密码体制**不是幂等**的（F2+F），那么多次迭代有可能提高密码体制的安全性。
2.   采用迭代结构的优点：软、硬件实现**节省了代码（硬件）资源。**
3.  **混淆：明文/密钥和密文之间的关系复杂。**
4.  **扩散：明文/密钥的每一个比特都影响密文的每一个比特。**

## Des概述 ##

*  明文和密文**分组长度为64比特**
 *  算法包含两部分：**迭代加解密**和**密钥编排**
 *  Feistel结构（加解密相似）：加密和解密除密钥编排不同外，完全相同
 *  密钥长度：56比特（DES的密钥空间：![2^\{56\}][2_56]），每7比特后为一个奇偶校验位（第8位），**共64比特**
 *  轮函数采用**混乱和扩散**的组合，共**16轮**

**整体结构**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHlfa2lsbGVyOQ_size_16_color_FFFFFF_t_70][]

明文进行初始置换（Initial Permutation,IP），通过密钥编排算法将密钥拆成16个，进行16轮迭代，最后通过逆置换得到密文。

## **初始置换与逆置换** ##

将输入的**64位数据块**按位重新组合，把输出分为L0、R0两部分，每部分长32位。

表中的数字代表**新数据中此位置的数据在原数据中的位置**，即原数据块的第58位放到新数据的第1位，第50位放到第2位，……依此类推。置换后的数据分为L0和R0两部分。

逆置换就是放回原位置，例如，1位置在40位置，那么逆置换的第一个就是40，我就不一个个画了

由于初始置换是公开的，没有密码意义。有很多DES实现都去除了，有人认为是当时为了更好放到DES芯片中。

## Feistel结构 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHlfa2lsbGVyOQ_size_16_color_FFFFFF_t_70 1][] 一轮迭代

按下述规则进行16次迭代，1≤i≤16

![L\_i=R\_i][L_i_R_i]

![R\_i=L\_\{i-1\}\\bigoplus f(R\_\{i-1\},K\_i)][R_i_L_i-1_bigoplus f_R_i-1_K_i]

## **轮函数F** ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHlfa2lsbGVyOQ_size_16_color_FFFFFF_t_70 2][]

F(![R\_\{i-1\}][R_i-1],![K\_i][K_i])以**长度为32比特串**![R\_\{i-1\}][R_i-1]作为第一输入，以长度为**48比特串**![K\_i][K_i]作为第二个输入，产生**长度为32比特**的输出。

### E扩展 ###

将![R\_\{i-1\}][R_i-1]**扩展为48位**，左右两列数据是扩展的数据，扩展的数据是从相邻位置取的一位，可理解为循环队列。靠近32位的位为1，靠近1位的位为32，其余就是下一行首或上一行末。

### 密钥加 ###

将![R\_\{i-1\}][R_i-1]的E扩展和![K\_i][K_i]进行异或

### S盒代换 ###

使用8个S盒S1……S8，每个Si是一个固定的**4\*16阶矩阵**，其元素取0~15之间的整数。  
给定长度为6的比特串，如**Bj=b1b2b3b4b5b6**，Sj(Bj)计算如下：

1.  **b1b6**两个比特确定了Sj的**行r**的二进制表示（0≤r≤3），
2.  **b2b3b4b5**四个比特确定了Sj的**列c**的二进制表示（0≤c≤15），
3.  Sj(Bj)定义成**长度为4**的比特串的值**Sj(r,c)**。由此可以算出**Cj=Sj(Bj)**，1≤j≤8。

S盒1如下：

其他的我就不粘贴了，都是公开的，网上能找到，这里只是为了举个例子。

假如，S1的输入Bj为110011

1.  b1b6为11，r=3
2.  b2b3b4b5为1001，c=9
3.  S1(3,9)为11，二进制为1011，Cj就是11了，即用1011替换了110011。

### P置换 ###

P盒如下：

长度为32比特串C=C1C2C3C4C5C6C7C8，根据上面的进行替换，原理和前面的IP一样，就是按照P盒放原始数据的多少位，第一个就放C的第16位，依次类推，最后组合一下即可，不再举例。

## 密钥编排 ##

前面是迭代加解密，接下来说下密钥编排，密钥编排就是通过密钥K，获得每轮的密钥ki，过程如下

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHlfa2lsbGVyOQ_size_16_color_FFFFFF_t_70 3][]

给定64比特密钥K，根据固定的置换PC-1来处理K得到PC-1(K)=C0D0,其中C0和D0分别由**最前和最后28比特组成**。下面是PC-1，注意，不包括8,16,24,32,40,48,56和64，前面提到，这些是校验位。

计算Ci=LSi(Ci-1)和Di=LS(Di-1)，且Ki=PC-2(CiDi)，LSi表示循环左移两个或一个位置，具体地，如果**i=1，2，9，16就移一个位置**，否则就移两个位置，PC-2是另一个固定的置换。下面是PC-2

以上就是一轮中获取Ki的过程，每轮选取密钥K的不同48比特进行PC-2的置换，同样是16个矩阵，长宽与PC-2相同，这里就不粘贴了，不然文章太长了。

# 3Des #

3DES，顾名思义，使用三次DES算法，有两种模式。

DES-EEE3模式：使用 **P->DES加密->DES加密->DES加密->C** 进行加密，使用 **C->DES解密->DES解密->DES解密->P** 进行解密。

DES-EDE3模式：使用 **P->DES加密->DES解密->DES加密->C** 进行加密，使用 **C->DES解密->DES加密->DES解密->P** 进行解密。

## 优缺点 ##

优点：

*  密钥长度增加到112位或168位，克服了DES面临的穷举攻击。
 *  相对于DES，增强了算法复杂度，提高了安全性。
 *  由于DES已经大规模使用，升级到3DES比更新新算法成本小得多。
 *  DES比其它任何加密算法受到的分析时间都长的多，相应地，3DES抗分析能力更强。

不足：

*  3DES加解速度较慢。
 *  虽然密钥长度增加了，但明文分组长度没变，与密钥长度的增长不匹配。

# 分组模式 #

分组密码在加密时，明文分组的长度是固定的，而实际应用中待加密消息的数据量是不定的，数据格式多种多样。为了能在各种应用场合使用DES，美国在FIPS PUS 74和81中定义了DES的4种运行模式：  
ECB，CBC，CFB，OFB，分组密码工作模式描述了如何重复加密比较长的多个数据块。

ECB，CBC是块模式，CFB、OFB是流模式。ECB安全性比较差，先不学了，Go的包中也没有。

## CBC ##

CBC(Cipher Block Chaining, 密码块链)模式中每一个分组要先和**前一个分组加密后的数据进行异或操作**，然后**再进行加密**。

加密：![C\_i=E(P\_i\\oplus C\_\{i-1\},K)][C_i_E_P_i_oplus C_i-1_K]

解密：![P\_i=D(C\_i,K) \\oplus C\_\{i-1\}][P_i_D_C_i_K_ _oplus C_i-1]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHlfa2lsbGVyOQ_size_16_color_FFFFFF_t_70 4][]

*  IV：initialization vector，初始向量，
 *  将长消息分块，若最后一个分块不足分组长度，则需要**填充**
 *  加密和解密过程分别调用加密算法和解密算法
 *  存在密文扩展（明文填充带来的扩展和**IV传输的扩展**）
 *  密文块需**按顺序逐一解密**
 *  存在错误传播（只传播下一块密文）
 *  适合**大于一个分组长度的长数据加密**

## CFB ##

CFB(Cipher Feedback, 密码反馈)模式和CBC模式比较相似，**前一个分组的密文加密后**和**当前分组的明文异或操作**生成当前分组的密文。

加密：![C\_i=E(C\_\{i-1\},K)\\oplus P\_i][C_i_E_C_i-1_K_oplus P_i]

解密：![P\_i=E(C\_\{i-1\},K) \\oplus C\_i][P_i_E_C_i-1_K_ _oplus C_i]

注意，**解密函数与加密函数一致**。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHlfa2lsbGVyOQ_size_16_color_FFFFFF_t_70 5][]

*  消息作为比特流进行加密，**无须分组填充**
 *  加密和解密过程**只调用加密算法**
 *  存在密文扩展（**IV传输的扩展**）
 *  密文块需按顺序逐一解密
 *  存在错误传播（只传播后面的几块）
 *  适合大于一个分组长度的长数据加密
 *  可用于自同步序列密码

## OFB ##

OFB(Output Feedback，输出反馈)模式与CFB模式类似，区别在于使用上一个分组的密码序列加密生成当前分组的密码序列。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHlfa2lsbGVyOQ_size_16_color_FFFFFF_t_70 6][]

**总结**

*  ECB是最快、最简单的分组密码模式，但它的安全性最弱，一般**不推荐**使用ECB加密消息，但如果是加密随机数据，如密钥，ECB则是最好的选择。
 *  **CBC适合文件加密**，而且有少量错误时不会造成同步失败，**是软件加密的最好选择。**
 *  CFB通常是加密分组序列所选择的模式，它也能容忍少量错误扩展，且具有同步恢复功能。**推荐使用CTR模式代替。**
 *  OFB是在极易出错的环境中选用的模式，但需有高速同步机制。**推荐使用CTR模式代替。**

CTR模式在学AES时再说。

好，以上都没什么用，因为DES被破解啦！！！（看到这句话的小伙伴都快哭了）不过，加强版还可以用，接下来就说说3DES。

# Des的Go实现 #

我们不是使用Go语言来实现Des，已经有大神写好了，我们会调用就可以了。

**des包**

> func NewCipher(key \[\]byte) (cipher.Block, error)

创建并返回一个使用DES算法的cipher.Block接口。

**cipher包**

> func NewCBCEncrypter(b Block, iv \[\]byte) BlockMode

返回一个密码分组链接模式的、底层用b加密的BlockMode接口，初始向量iv的长度必须等于b的块尺寸。

BlockMode的方法

> CryptBlocks(dst, src \[\]byte)

加密或解密连续的数据块，src的尺寸必须是块大小的整数倍，**src和dst可指向同一内存地址 **

> func NewCBCDecrypter(b Block, iv \[\]byte) BlockMode

返回一个密码分组链接模式的、底层用b解密的BlockMode接口，初始向量iv必须和加密时使用的iv相同。

## 明文填充 ##

CBC模式需要填充，解密后我们还需要去掉填充，由于填充什么没有要求，我们就填充缺少的长度，这样去掉填充时就容易切片了。

func PaddingLastGroup(plainText []byte,blockSize int) []byte{
    	padNum := blockSize - len(plainText)%blockSize
    	char := []byte{byte(padNum)}
    	newPlain := bytes.Repeat(char,padNum)
    	plainText = append(plainText,newPlain...)
    	return plainText
    }

func UnpaddingLastGroup(plainText []byte) []byte {
    	length := len(plainText)
    	number := int(plainText[length-1])
    	return plainText[:length-number]
    }

## 加密 ##

*  使用des.NewCipher获取块
 *  填充明文
 *  使用cipher.NewCBCEncrypter生成CBC模式块
 *  使用模式块的CryptBlocks进行加密，由于可指向同一内存地址，我们仍使用同一变量，节省内存

func DesEncrypt(plainText,iv, key []byte) ([]byte,error) {
    	if len(iv) != 8{
    		_, file, line, _ := runtime.Caller(0)
    		return nil,util.Error(file,line+1,errors.IvError)
    	}
    	block, err :=des.NewCipher(key)
    	if err != nil{
    		_, file, line, _ := runtime.Caller(0)
    		return nil,util.Error(file,line+1,errors.DesKeyError)
    	}
    	// padding plainText
    	newText := util.PaddingLastGroup(plainText,des.BlockSize)
    	// Create a CBC interface
    	blockMode := cipher.NewCBCEncrypter(block,iv)
    	// use same one to save space
    	blockMode.CryptBlocks(newText,newText)
    	return newText,nil
    }

## 解密 ##

*  使用des.NewCipher获取块
 *  使用cipher.NewCBCDecrypter生成CBC模式块
 *  使用模式块的CryptBlocks进行解密
 *  去掉明文填充

func DesDecrypt(cipherText,iv,key []byte) ([]byte,error) {
    	if len(iv) != 8{
    		_, file, line, _ := runtime.Caller(0)
    		return nil,util.Error(file,line+1,errors.IvError)
    	}
    	block, err :=des.NewCipher(key)
    	if err != nil{
    		_, file, line, _ := runtime.Caller(0)
    		return nil,util.Error(file,line+1,errors.DesKeyError)
    	}
    	// Create a CBC interface
    	blockMode := cipher.NewCBCDecrypter(block,iv)
    	plainText := make([]byte,len(cipherText))
    	blockMode.CryptBlocks(plainText,cipherText)
    	return util.UnpaddingLastGroup(plainText),nil
    }

部分测试代码

iv := []byte("12345678")
    	key := []byte("ladykill")
    	plainText := []byte("hellocrypto")
    	cipherText,err := DesEncrypt(plainText,iv,key)
    	if err != nil{
    		fmt.Println(err)
    		os.Exit(0)
    	}
    	fmt.Printf("加密后：%s\n",string(cipherText))
    	decryText,_ := DesDecrypt(cipherText,iv,key)
    	fmt.Printf("解密后：%s\n",string(decryText))

## 结果截图 ##

![20210605162716957.PNG][]

3Des只需要创建时使用des.NewTripleDESCipher(key)即可。

代码我放到了gitee上：[https://gitee.com/frankyu365/gocrypto][https_gitee.com_frankyu365_gocrypto]

您可以查看仓库Readme文档或[Go-包管理(管理工具对比及go mod的使用)][Go-_go mod]来进行安装

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHlfa2lsbGVyOQ_size_16_color_FFFFFF_t_70 7][]

# 参考 #

《现代密码学教程 谷利泽，杨义先等》

[Go标准库-crypto/des][Go_-crypto_des]

[Go标准库-crypto/cipher][Go_-crypto_cipher]

更多Go相关内容：[Go-Golang学习总结笔记][Go-Golang]

有问题请下方评论，转载请注明出处，并附有原文链接，谢谢！如有侵权，请及时联系。如果您感觉有所收获，自愿打赏，可选择支付宝18833895206（小于），您的支持是我不断更新的动力。

[2_56]: https://latex.codecogs.com/gif.latex?2%5E%7B56%7D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHlfa2lsbGVyOQ_size_16_color_FFFFFF_t_70]: /images/20221014/2e5d365305454db38037a29f32d88b81.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHlfa2lsbGVyOQ_size_16_color_FFFFFF_t_70 1]: /images/20221014/a6716e2527bb4110b4632b9222635c30.png
[L_i_R_i]: https://latex.codecogs.com/gif.latex?L_i%3DR_i
[R_i_L_i-1_bigoplus f_R_i-1_K_i]: https://latex.codecogs.com/gif.latex?R_i%3DL_%7Bi-1%7D%5Cbigoplus%20f%28R_%7Bi-1%7D%2CK_i%29
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHlfa2lsbGVyOQ_size_16_color_FFFFFF_t_70 2]: /images/20221014/dab8e0fee3e44de4944cc8866c38ead4.png
[R_i-1]: https://latex.codecogs.com/gif.latex?R_%7Bi-1%7D
[K_i]: https://latex.codecogs.com/gif.latex?K_i
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHlfa2lsbGVyOQ_size_16_color_FFFFFF_t_70 3]: /images/20221014/d5836c7029e942c0a6c68547d96c7340.png
[C_i_E_P_i_oplus C_i-1_K]: https://latex.codecogs.com/gif.latex?C_i%3DE%28P_i%5Coplus%20C_%7Bi-1%7D%2CK%29
[P_i_D_C_i_K_ _oplus C_i-1]: https://latex.codecogs.com/gif.latex?P_i%3DD%28C_i%2CK%29%20%5Coplus%20C_%7Bi-1%7D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHlfa2lsbGVyOQ_size_16_color_FFFFFF_t_70 4]: /images/20221014/7bc833eb240b48cf8e97747dfb864426.png
[C_i_E_C_i-1_K_oplus P_i]: https://latex.codecogs.com/gif.latex?C_i%3DE%28C_%7Bi-1%7D%2CK%29%5Coplus%20P_i
[P_i_E_C_i-1_K_ _oplus C_i]: https://latex.codecogs.com/gif.latex?P_i%3DE%28C_%7Bi-1%7D%2CK%29%20%5Coplus%20C_i
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHlfa2lsbGVyOQ_size_16_color_FFFFFF_t_70 5]: /images/20221014/8129c59b45384b178de1ec6f44d7c7fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHlfa2lsbGVyOQ_size_16_color_FFFFFF_t_70 6]: /images/20221014/292c37d5577e4b729b60ac50d3f61e3c.png
[20210605162716957.PNG]: /images/20221014/e7275d8ebefe43718859d2fa19449ff9.png
[https_gitee.com_frankyu365_gocrypto]: https://gitee.com/frankyu365/gocrypto
[Go-_go mod]: https://blog.csdn.net/lady_killer9/article/details/116128497
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHlfa2lsbGVyOQ_size_16_color_FFFFFF_t_70 7]: /images/20221014/91f2112a968f4234bfb912b6ab513413.png
[Go_-crypto_des]: https://studygolang.com/static/pkgdoc/pkg/crypto_des.htm
[Go_-crypto_cipher]: https://studygolang.com/static/pkgdoc/pkg/crypto_cipher.htm
[Go-Golang]: https://blog.csdn.net/lady_killer9/article/details/115491317