区块链背后的信息安全(2) DES、3DES加密算法原理及其GO语言实现

# DES、3DES加密算法原理及其GO语言实现

DES加密算法，为对称加密算法中的一种。70年代初由IBM研发，后1977年被美国国家标准局采纳为数据加密标准，即DES全称的由来：Data Encryption Standard。

对称加密算法，是相对于非对称加密算法而言的。两者区别在于，对称加密在加密和解密时使用同一密钥，而非对称加密在加密和解密时使用不同的密钥，即公钥和私钥。

常见的DES、3DES、AES均为对称加密算法，而RSA、椭圆曲线加密算法，均为非对称加密算法。

DES是以64比特的明文为一个单位来进行加密的，超过64比特的数据，要求按固定的64比特的大小分组，分组有很多模式，后续单独总结，暂时先介绍DES加密算法。

DES使用的密钥长度为64比特，但由于每隔7个比特设置一个奇偶校验位，因此其密钥长度实际为56比特。奇偶校验为最简单的错误检测码，即根据一组二进制代码中1的个数是奇数或偶数来检测错误。

## Feistel网络

DES的基本结构，由IBM公司的Horst Feistel设计，因此称Feistel网络。

在Feistel网络中，加密的每个步骤称为轮，经过初始置换后的64位明文，进行了16轮Feistel轮的加密过程，最后经过终结置换后形成最终的64位密文。

如下为Feistel网络的示意图：

64比特明文被分为左、右两部分处理，右侧数据和子密钥经过轮函数f生成用于加密左侧数据的比特序列，与左侧数据异或运算，运算结果输出为加密后的左侧，右侧数据则直接输出为右侧。

其中子密钥为本轮加密使用的密钥，每次Feistel均使用不同的子密钥。子密钥的计算，以及轮函数的细节，稍后下文介绍。

由于一次Feistel轮并不会加密右侧，因此需要将上一轮输出后的左右两侧对调后，重复Feistel轮的过程，DES算法共计进行16次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置换表

var permutedChoice2 = [ 48] ## Feistel轮函数

每次Feistel轮函数内部，均经过4种运算，即：

* 1、扩展置换：右侧32位做扩展置换，扩展置换将32位输入扩展成为48位输出，使得扩展后输出数据长度与48位子密钥等长。

* 2、异或运算：右侧32位扩展置换为48位后，与48位子密钥做异或运算。

* 3、S盒置换：将异或运算后的48位结果，分成8个6位的块，每块通过S盒置换产生4位的输出，8个块S盒置换后组成32位的输出。

S盒置换的过程为：6位中取第1位和第6位组成行号，剩余第2、3、4、5位组成列号，从S盒置换表中取出相应行、列的十进制数，并转化为4位二进制数，即为S盒输出。

* 4、P盒置换：S盒置换后的32位输出数据，进行P盒置换，仍然输出为32位数据。

如下为Feistel轮函数示意图：

go标准库中DES 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>>42、sBoxLocations <<= 6，按每6位分块

        sBoxLocation := uint8(sBoxLocations>> 42) & 0x3f

        sBoxLocations <<= 6

         //6位中取第1位和第6位组成行号

        row := (sBoxLocation & 0x1) | ((sBoxLocation & 0x20) >> 4)

         //剩余第2、3、4、5位组成列号

        column := (sBoxLocation >> 1) & 0xf

         //feistelBox包括了S盒置换和P盒置换的实现

        sBoxResult ^= feistelBox[i][ 16*row+column]

    }

     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() {

     for s := range sBoxes {

         4; i++ {

             for j := 0; j < 16; j++ {

                f := uint64(sBoxes[s][i][j]) << ( 4 * ( 7 - uint(s)))

                f = permuteBlock(f,permutationFunction[:])

                feistelBox[s][ 16*i+j] = uint32(f)

            }

        }

    }

}

//代码位置src/crypto/des/block.go

```

附go标准库中使用的扩展置换表和P盒置换表：

```go

//扩展置换表

var expansionFunction = [ //P盒置换表

var permutationFunction = [ 32] //代码位置src/crypto/des/const.go

```

附go标准库中使用的S盒置换表：

```go

var sBoxes = [ 8][ 4][ uint8{

     // 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