# DES、3DES加密算法原理及其GO语言实现
DES加密算法,为对称加密算法中的一种。70年代初由IBM研发,后1977年被美国国家标准局采纳为数据加密标准,即DES全称的由来:Data Encryption Standard。
对称加密算法,是相对于非对称加密算法而言的。两者区别在于,对称加密在加密和解密时使用同一密钥,而非对称加密在加密和解密时使用不同的密钥,即公钥和私钥。
常见的DES、3DES、AES均为对称加密算法,而RSA、椭圆曲线加密算法,均为非对称加密算法。
DES是以64比特的明文为一个单位来进行加密的,超过64比特的数据,要求按固定的64比特的大小分组,分组有很多模式,后续单独总结,暂时先介绍DES加密算法。
## Feistel网络
DES的基本结构,由IBM公司的Horst Feistel设计,因此称Feistel网络。
在Feistel网络中,加密的每个步骤称为轮,经过初始置换后的64位明文,进行了16轮Feistel轮的加密过程,最后经过终结置换后形成最终的64位密文。
如下为Feistel网络的示意图:
其中子密钥为本轮加密使用的密钥,每次Feistel均使用不同的子密钥。子密钥的计算,以及轮函数的细节,稍后下文介绍。
DES加密和解密的过程一致,均使用Feistel网络实现,区别仅在于解密时,密文作为输入,并逆序使用子密钥。
go标准库中DES算法实现如下:
```go
func cryptBlock(subkeys []
uint64,dst,src []
byte,decrypt
bool) {
b := binary.BigEndian.Uint64(src)
//初始置换
b = permuteInitialBlock(b)
left,right := uint32(b>>
32),uint32(b)
var subkey uint64
//共计16次feistel轮
for i :=
0; i <
16; i++ {
//加密和解密使用子密钥顺序相反
if decrypt {
subkey = subkeys[
15-i]
}
else {
subkey = subkeys[i]
}
//feistel轮函数
left,right = right,left^feistel(right,subkey)
}
//最后一轮无需对调
preOutput := (uint64(right) <<
32) | uint64(left)
//终结置换
binary.BigEndian.PutUint64(dst,permuteFinalBlock(preOutput))
}
//代码位置src/crypto/des/block.go
```
## 初始置换和终结置换
进入Feistel轮之前,64位明文需做一次初始置换。Feistel轮结束后,需做一次反向操作,即终结置换。
初始置换和终结置换目的是为加强硬件的破解难度而加的。
附go标准库中使用的初始置换表和终结置换表如下:
```go
//初始置换表
var initialPermutation = [
64]
byte{
6,14,168);">22,168);">30,168);">38,168);">46,168);">54,168);">62,
4,168);">12,168);">20,168);">28,168);">36,168);">44,168);">52,168);">60,168);">2,168);">10,168);">18,168);">26,168);">34,168);">42,168);">50,168);">58,168);">0,168);">8,168);">16,168);">24,168);">32,168);">40,168);">48,168);">56,168);">7,168);">15,168);">23,168);">31,168);">39,168);">47,168);">55,168);">63,168);">5,168);">13,168);">21,168);">29,168);">37,168);">45,168);">53,168);">61,168);">3,168);">11,168);">19,168);">27,168);">35,168);">43,168);">51,168);">59,168);">1,168);">9,168);">17,168);">25,168);">33,168);">41,168);">49,168);">57,
}
//终结置换表
var finalPermutation = [
//代码位置src/crypto/des/const.go
```
## 子密钥的计算
DES初始密钥为64位,其中8位用于奇偶校验,实际密钥为56位,64位初始密钥经过PC-1密钥置换后,生成56位串。
经PC-1置换后56位的串,分为左右两部分,各28位,分别左移1位,形成C0和D0,C0和D0合并成56位,经PC-2置换后生成48位子密钥K0。
C0和D0分别左移1位,形成C1和D1,C1和D1合并成56位,经PC-2置换后生成子密钥K1。
以此类推,直至生成子密钥K15。但注意每轮循环左移的位数,有如下规定:
```go
var ksRotations = [
16]
uint8{
1}
//代码位置src/crypto/des/const.go
```
如下为子密钥计算示意图:
go标准库中DES子密钥计算的代码如下:
```go
func (c *desCipher) generateSubkeys(keyBytes []
byte) {
key := binary.BigEndian.Uint64(keyBytes)
//PC-1密钥置换,生成56位串
permutedKey := permuteBlock(key,permutedChoice1[:])
//56位串分左右两部分,各28位,ksRotate为依次循环左移1位
leftRotations := ksRotate(uint32(permutedKey >>
28))
rightRotations := ksRotate(uint32(permutedKey<<
4) >>
4)
//生成子密钥
//合并左右两部分,之后PC-2置换
pc2Input := uint64(leftRotations[i])<<
28 | uint64(rightRotations[i])
c.subkeys[i] = permuteBlock(pc2Input,permutedChoice2[:])
}
}
//代码位置src/crypto/des/block.go
```
附go标准库中使用的PC-1置换表和PC-2置换表:
```go
//PC-1置换表
var permutedChoice1 = [
56]
//PC-2置换表
每次Feistel轮函数内部,均经过4种运算,即:
* 2、异或运算:右侧32位扩展置换为48位后,与48位子密钥做异或运算。
S盒置换的过程为:6位中取第1位和第6位组成行号,剩余第2、3、4、5位组成列号,从S盒置换表中取出相应行、列的十进制数,并转化为4位二进制数,即为S盒输出。
如下为Feistel轮函数示意图:
```go
func feistel(right
uint32,key
uint64) (result
uint32) {
//右侧32位扩展置换为48位,并与48位子密钥做异或运算
sBoxLocations := key ^ expandBlock(right)
var sBoxResult uint32
for i := uint8(
0); i <
8; i++ {
sBoxLocations <<=
6
//6位中取第1位和第6位组成行号
//剩余第2、3、4、5位组成列号
}
return sBoxResult
}
var feistelBox [8][64]uint32
//P盒置换
func permuteBlock(src
uint8) (block
uint64) {
for position,n :=
range permutation {
bit := (src >> n) &
1
block |= bit << uint((
len(permutation)-
1)-position)
}
return
}
//初始化feistelBox
func init() {
4; i++ {
for j :=
0; j <
16; j++ {
f = permuteBlock(f,permutationFunction[:])
feistelBox[s][
16*i+j] = uint32(f)
}
}
}
}
//代码位置src/crypto/des/block.go
```
附go标准库中使用的扩展置换表和P盒置换表:
```go
//扩展置换表
var expansionFunction = [
//P盒置换表
```
附go标准库中使用的S盒置换表:
```go
// S-Box 1
{
{
7},
{
8},168);">0},168);">13},
},
// S-Box 2
{
{
10},168);">5},168);">15},168);">9},78);">// S-Box 3
{
{
1},168);">12},78);">// S-Box 4
{
{
4},168);">14},78);">// S-Box 5
{
{
6},168);">3},78);">// S-Box 6
{
{
11},78);">// S-Box 7
{
{
2},78);">// S-Box 8
{
{
## 3DES
DES是一个经典的对称加密算法,但也缺陷明显,即56位的密钥安全性不足,已被证实可以在短时间内破解。
为解决此问题,出现了3DES,也称Triple DES,3DES为DES向AES过渡的加密算法,它使用3条56位的密钥对数据进行三次加密。
为了兼容普通的DES,3DES并没有直接使用加密->加密->加密的方式,而是采用了加密->解密->加密的方式。
当三重密钥均相同时,前两步相互抵消,相当于仅实现了一次加密,因此可实现对普通DES加密算法的兼容。
3DES解密过程,与加密过程相反,即逆序使用密钥。
如下为三重DES示意图:
如下为3DES兼容DES示意图:
go标准中3DES加密算法的实现如下:
```go
type
tripleDESCipher
struct {
cipher1,cipher2,cipher3 desCipher
}
func NewTripleDESCipher(key []
byte) (cipher.Block,error) {
if
len(key) !=
24 {
return
nil,KeySizeError(
len(key))
}
c :=
new(tripleDESCipher)
c.cipher1.generateSubkeys(key[:
8])
c.cipher2.generateSubkeys(key[
8:
16])
c.cipher3.generateSubkeys(key[
16:])
return c,214);">nil
}
//3DES加密
func (c *tripleDESCipher) Encrypt(dst,176);">byte) {
c.cipher1.Encrypt(dst,src)
c.cipher2.Decrypt(dst,dst)
c.cipher3.Encrypt(dst,dst)
}
//3DES解密
func (c *tripleDESCipher) Decrypt(dst,176);">byte) {
c.cipher3.Decrypt(dst,src)
c.cipher2.Encrypt(dst,dst)
c.cipher1.Decrypt(dst,dst)
}
//代码位置src/crypto/des/cipher.go
```
## 后记
相比DES,3DES因密钥长度变长,安全性有所提高,但其处理速度不高。
因此又出现了AES加密算法,AES较于3DES速度更快、安全性更高,后续单独总结。
网址:http://www.qukuailianxueyuan.io/
欲领取造币技术与全套虚拟机资料
区块链技术交流QQ群:756146052 备注:CSDN
尹成学院微信:备注:CSDN
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。