关于密码学:密码学之对称加密

1. 密码学简介
2. 对称加密
3. 分组加密模式
4. 非对称加密
5. 单向散列函数
6. 音讯认证码
7. 数字签名
8. 证书
9.SSL/TLS

本文将介绍比特序列运算中的异或运算，同时简略介绍 DES、3DES、AES 等对称加密算法，最初给出对应的 Golang 加密代码。

源代码

首先咱们要明确二个概念，一个是计算机编码，咱们都晓得计算机操作的对象并不是文字图像，而是有 0 和 1 排列组成的比特序列；一个是异或运算（XOR）, 二个不同的比特位异或运算后果是 1，不同的比特位异或运算后果是 0。

假如咱们将 01001100 这个比特序列成为 A，将 10101010 这个比特序列成为 B，那么 A 与 B 的异或运算后果就如下所示：

因为二个雷同的数进行异或运算的后果是 0，因而如果将 A 与 B 异或的后果再与 B 进行异或估算，则后果就会变回 A。

可能你曾经发现了，下面的计算和加密、解密的步骤十分类似。

将明文 A 与秘钥 B 进行加密运算，失去密文 A⊕B
将密文 A⊕B 用秘钥 B 进行解密，失去明文 A

实际上，次要抉择一个适合的 B，仅仅应用异或运算就能够实现一个高强度的明码。

DES（Data EncryptionStandard） 是 1977 年美国联邦信息处理规范（FIPS）中所采纳的一种对称明码（FIPS46.3）。DES 始终以来被美国以及其余国家的政府和银行等宽泛应用。然而，随着计算机的提高，当初 DES 曾经可能被暴力破解，强度大不如前了。

RSA 公司举办过破解 DES 密钥的较量（DESChallenge），咱们能够看一看 RSA 公司官网颁布的比赛结果：

1997 年的 DES Challenge1 中用了 96 天破译密钥
1998 年的 DES ChallengeIl- I 中用了 41 天破译密钥
1998 年的 DES ChallengeII- 2 中用了 56 小时破译密钥
1999 年的 DES ChallengeIll 中只用了 22 小时 15 分钟破译密钥

因为 DES 的密文能够在短时间内被破译，因而除了用它来解密以前的密文以外，当初咱们不应该再应用 DES 了。

DES 是一种将 64 比特的明文加密成 64 比特的密文的对称明码算法，它的密钥长度是 56 比特。只管 <font color=”red”> 从规格上来说，DES 的密钥长度是 64 比特，但因为每隔 7 比特会设置一个用于谬误查看的比特，因而本质上其密钥长度是 56 比特 </font>。

<font color=”red”>DES 是以 64 比特的明文（比特序列）为一个单位来进行加密的 </font>，这个 64 比特的单位称为分组 。一般来说，以分组为单位进行解决的明码算法称为 分组明码（blockcipher），DES 就是分组明码的一种。

DES 每次只能加密 64 比特的数据，如果要加密的明文比拟长，就须要对 DES 加密进行迭代（重复），而迭代的具体形式就称为模式（mode）（后续文章具体解说分组明码的模式）。

大 B -> bit

小 b -> byte

秘钥长度(56bit + 8bit)/8 = 8byte

DES 的加密与解密 – 图例

加解密实现思路

加密 – CBC 分组模式
1. 创立并返回一个应用 DES 算法的 cipher.Block 接口
  - 秘钥长度为 64bit, 即 64/8 = 8 字节(byte)
2. 对最初一个明文分组进行数据填充
  - DES 是以 64 比特的明文（比特序列）为一个单位来进行加密的
  - 最初一组不够 64bit, 则须要进行数据填充 ( 参考第三章)
3. 创立一个明码分组为链接模式的, 底层应用 DES 加密的 BlockMode 接口
4. 加密间断的数据块
解密
1. 创立并返回一个应用 DES 算法的 cipher.Block 接口
2. 创立一个明码分组为链接模式的, 底层应用 DES 解密的 BlockMode 接口
3. 数据块解密
4. 去掉最初一组的填充数据

加解密的代码实现

在 Go 中应用 DES 须要导入的包:

import (
    "crypto/des"
    "crypto/cipher"
    "fmt"
    "bytes"
)

DES 加密代码:

// src -> 要加密的明文
// key -> 秘钥, 大小为: 8byte
func DesEncrypt_CBC(src, key []byte) []byte{
    // 1. 创立并返回一个应用 DES 算法的 cipher.Block 接口
    block, err := des.NewCipher(key)
    // 2. 判断是否创立胜利
    if err != nil{panic(err)
    }
    // 3. 对最初一个明文分组进行数据填充
    src = PKCS5Padding(src, block.BlockSize())
    // 4. 创立一个明码分组为链接模式的, 底层应用 DES 加密的 BlockMode 接口
    //    参数 iv 的长度, 必须等于 b 的块尺寸
    tmp := []byte("helloAAA")
    blackMode := cipher.NewCBCEncrypter(block, tmp)
    // 5. 加密间断的数据块
    dst := make([]byte, len(src))
    blackMode.CryptBlocks(dst, src)

    fmt.Println("加密之后的数据:", dst)

    // 6. 将加密数据返回
    return dst
}

DES 解密代码

// src -> 要解密的密文
// key -> 秘钥, 和加密秘钥雷同, 大小为: 8byte
func DesDecrypt_CBC(src, key []byte) []byte {
    // 1. 创立并返回一个应用 DES 算法的 cipher.Block 接口
    block, err := des.NewCipher(key)
    // 2. 判断是否创立胜利
    if err != nil{panic(err)
    }
    // 3. 创立一个明码分组为链接模式的, 底层应用 DES 解密的 BlockMode 接口
    tmp := []byte("helloAAA")
    blockMode := cipher.NewCBCDecrypter(block, tmp)
    // 4. 解密数据
    dst := src
    blockMode.CryptBlocks(src, dst)
    // 5. 去掉最初一组填充的数据
    dst = PKCS5UnPadding(dst)

    // 6. 返回后果
    return dst
}

最初一个分组增加填充数据和移除增加数据代码

// 应用 pks5 的形式填充
func PKCS5Padding(ciphertext []byte, blockSize int) []byte{
    // 1. 计算最初一个分组缺多少个字节
    padding := blockSize - (len(ciphertext)%blockSize)
    // 2. 创立一个大小为 padding 的切片, 每个字节的值为 padding
    padText := bytes.Repeat([]byte{byte(padding)}, padding)
    // 3. 将 padText 增加到原始数据的后边, 将最初一个分组短少的字节数补齐
    newText := append(ciphertext, padText...)
    return newText
}

// 删除 pks5 填充的尾部数据
func PKCS5UnPadding(origData []byte) []byte{
    // 1. 计算数据的总长度
    length := len(origData)
    // 2. 依据填充的字节值得到填充的次数
    number := int(origData[length-1])
    // 3. 将尾部填充的 number 个字节去掉
    return origData[:(length-number)]
}

测试函数

func DESText() {
    // 加密
    key := []byte("11111111")
    result := DesEncrypt_CBC([]byte("床前明月光, 疑是地上霜. 举头望明月, 抬头思故土."), key)
    fmt.Println(base64.StdEncoding.EncodeToString(result))
    // 解密
    result = DesDecrypt_CBC(result, key)
    fmt.Println("解密之后的数据:", string(result))
}

重要的函数阐明

生成一个底层应用 DES 加 / 解密的 Block 接口对象

函数对应的包: import "crypto/des"
func NewCipher(key []byte) (cipher.Block, error)
    - 参数 key: des 对称加密应用的明码, 明码长度为 64bit, 即 8byte


2. 创立一个明码分组为 CBC 模式, 底层应用 b 加密的 BlockMode 接口对象

函数对应的包: import “crypto/cipher”
func NewCBCEncrypter(b Block, iv []byte) BlockMode

   - 参数 b: 应用 des.NewCipher 函数创立出的 Block 接口对象
   - 参数 iv: 当时筹备好的一个长度为一个分组长度的比特序列, 每个分组为 64bit, 即 8byte
   - 返回值: 失去的 BlockMode 接口对象


3. 应用 cipher 包的 BlockMode 接口对象对数据进行加 / 解密

接口对应的包: import “crypto/cipher”
type BlockMode interface {

   // 返回加密字节块的大小
   BlockSize() int
   // 加密或解密间断的数据块，src 的尺寸必须是块大小的整数倍，src 和 dst 可指向同一内存地址
   CryptBlocks(dst, src []byte)

}
接口中的 CryptBlocks(dst, src []byte) 办法:

   - 参数 dst: 传出参数, 存储加密或解密运算之后的后果 
   - 参数 src: 传入参数, 须要进行加密或解密的数据切片(字符串)


4. 创立一个明码分组为 CBC 模式, 底层应用 b 解密的 BlockMode 接口对象

函数对应的包: import “crypto/cipher”
func NewCBCDecrypter(b Block, iv []byte) BlockMode

   - 参数 b: 应用 des.NewCipher 函数创立出的 Block 接口对象
   - 参数 iv: 当时筹备好的一个长度为一个分组长度的比特序列, 每个分组为 64bit, 即 8byte, 
              该序列的值须要和 NewCBCEncrypter 函数的第二个参数 iv 值雷同
   - 返回值: 失去的 BlockMode 接口对象


5. 自定义函数介绍

对称加密加密须要对数据进行分组, 保障每个分组的数据长度相等, 如果最初一个分组长度不够, 须要进行填充
func PKCS5Padding(ciphertext []byte, blockSize int) []byte

   - 参数 ciphertext: 须要加密的原始数据
   - 参数 blockSize: 每个分组的长度, 跟应用的加密算法有关系
       * des：64bit，8byte
       * 3des：64bit，8byte
       * aes：128bit，16byte


###  三重 DES

> 当初 DES 曾经能够在事实的工夫内被暴力破解，因而咱们须要一种用来代替 DES 的分组明码，三重 DES 就是出于这个目标被开发进去的。>
> ** 三重 DES（triple-DES）是为了减少 DES 的强度，将 DES 反复 3 次所失去的一种明码算法，通常缩写为 3DES**。####  三重 DES 的加密

> 三重 DES 的加解密机制如下图所示：>
> 加 -> 解 -> 加 -> 目标是为了兼容 DES(如果三个秘钥都一样)
>
> 3des 秘钥长度 24 字节 = 1234567a 1234567b 1234567a
>
> 明文: 10
>
> 秘钥 1: 2
>
> 秘钥 2: 3
>
> 秘钥 3: 4
>
> 加密算法: 明文 + 秘钥
>
> 解密算法: 密文 - 秘钥
>
> 10+2-3+4

![](https://user-gold-cdn.xitu.io/2019/9/4/16cfcda088e502af?w=465&h=489&f=png&s=29597))
![](https://user-gold-cdn.xitu.io/2019/9/4/16cfcda3e14bd193?w=466&h=489&f=png&s=29187)

明文通过三次 DES 解决能力变成最初的密文，因为 **DES 密钥的长度本质上是 56 比特 **，因而 <font color="red"> 三重 DES 的密钥长度就是 56×3=168 比特, 加上用于谬误检测的标记位 8x3, 共 192bit</font>。从上图咱们能够发现，三重 DES 并不是进行三次 DES 加密（加密 --> 加密 --> 加密），而是 <font color="red">** 加密 --> 解密 --> 加密 **</font> 的过程。在加密算法中加人解密操作让人感觉很不堪设想，实际上这个办法是 IBM 公司设计进去的，目标是为了让三重 DES 可能兼容一般的 DES。<font color="red"> 当三重 DES 中所有的密钥都雷同时，三重 DES 也就等同于一般的 DES 了 </font>。这是因为在前两步加密 --> 解密之后，失去的就是最后的明文。因而，以前用 DES 加密的密文，就能够通过这种形式用三重 DES 来进行解密。也就是说，三重 DES 对 DES 具备向下兼容性。如果密钥 1 和密钥 3 应用雷同的密钥，而密钥 2 应用不同的密钥（也就是只应用两个 DES 密钥），这种三重 DES 就称为 DES-EDE2。EDE 示意的是加密（Encryption) --> 解密（Decryption)--> 加密（Encryption）这个流程。密钥 1、密钥 2、密钥 3 全副应用不同的比特序列的三重 DES 称为 DES-EDE3。只管三重 DES 目前还被银行等机构应用，但其处理速度不高，而且在安全性方面也逐步显现出了一些问题。#### Go 中对 3DES 的操作

##### 加解密实现思路

- ** 加密 - CBC 分组模式 **

  > 1. 创立并返回一个应用 3DES 算法的 cipher.Block 接口
  >    - ** 秘钥长度为 64bit*3=192bit, 即 192/8 = 24 字节(byte)**
  > 2. 对最初一个明文分组进行数据填充
  >    - 3DES 是以 64 比特的明文（比特序列）为一个单位来进行加密的
  >    - 最初一组不够 64bit, 则须要进行数据填充(** 参考第三章 **)
  > 3. 创立一个明码分组为链接模式的, 底层应用 3DES 加密的 BlockMode 接口
  > 4. 加密间断的数据块

- ** 解密 **

  > 1. 创立并返回一个应用 3DES 算法的 cipher.Block 接口
  > 2. 创立一个明码分组为链接模式的, 底层应用 3DES 解密的 BlockMode 接口
  > 3. 数据块解密
  > 4. 去掉最初一组的填充数据

##### 加解密的代码实现

3DES 加密代码

// 3DES 加密
func TripleDESEncrypt(src, key []byte) []byte {

// 1. 创立并返回一个应用 3DES 算法的 cipher.Block 接口
block, err := des.NewTripleDESCipher(key)
if err != nil{panic(err)
}
// 2. 对最初一组明文进行填充
src = PKCS5Padding(src, block.BlockSize())
// 3. 创立一个明码分组为链接模式, 底层应用 3DES 加密的 BlockMode 模型
blockMode := cipher.NewCBCEncrypter(block, key[:8])
// 4. 加密数据
dst := src
blockMode.CryptBlocks(dst, src)
return dst

}


3DES 解密代码

// 3DES 解密
func TripleDESDecrypt(src, key []byte) []byte {

// 1. 创立 3DES 算法的 Block 接口对象
block, err := des.NewTripleDESCipher(key)
if err != nil{panic(err)
}
// 2. 创立明码分组为链接模式, 底层应用 3DES 解密的 BlockMode 模型
blockMode := cipher.NewCBCDecrypter(block, key[:8])
// 3. 解密
dst := src
blockMode.CryptBlocks(dst, src)
// 4. 去掉尾部填充的数据
dst = PKCS5UnPadding(dst)
return dst

}


重要的函数阐明

1. 生成一个底层应用 3DES 加 / 解密的 Block 接口对象

函数对应的包: import “crypto/des”
func NewTripleDESCipher(key []byte) (cipher.Block, error)

   - 参数 key: 3des 对称加密应用的明码, 明码长度为(64*3)bit, 即(8*3)byte
   - 返回值 cipher.Block: 创立出的应用 DES 加 / 解密的 Block 接口对象


2. 创立一个明码分组为 CBC 模式, 底层应用 b 加密的 BlockMode 接口对象

函数对应的包: import “crypto/cipher”
func NewCBCEncrypter(b Block, iv []byte) BlockMode

   - 参数 b: 应用 des.NewTripleDESCipher 函数创立出的 Block 接口对象
   - 参数 iv: 当时筹备好的一个长度为一个分组长度的比特序列, 每个分组为 64bit, 即 8byte
   - 返回值: 失去的 BlockMode 接口对象


3. 应用 cipher 包的 BlockMode 接口对象对数据进行加 / 解密

接口对应的包: import “crypto/cipher”
type BlockMode interface {

   // 返回加密字节块的大小
   BlockSize() int
   // 加密或解密间断的数据块，src 的尺寸必须是块大小的整数倍，src 和 dst 可指向同一内存地址
   CryptBlocks(dst, src []byte)

}
接口中的 CryptBlocks(dst, src []byte) 办法:

   - 参数 dst: 传出参数, 存储加密或解密运算之后的后果 
   - 参数 src: 传入参数, 须要进行加密或解密的数据切片(字符串)


4. 创立一个明码分组为 CBC 模式, 底层应用 b 解密的 BlockMode 接口对象

函数对应的包: import “crypto/cipher”
func NewCBCDecrypter(b Block, iv []byte) BlockMode

   - 参数 b: 应用 des.NewTripleDESCipher 函数创立出的 Block 接口对象
   - 参数 iv: 当时筹备好的一个长度为一个分组长度的比特序列, 每个分组为 64bit, 即 8byte, 
              该序列的值须要和 NewCBCEncrypter 函数的第二个参数 iv 值雷同
   - 返回值: 失去的 BlockMode 接口对象


### AES

>AES（Advanced Encryption Standard）是取代其后任规范（DES）而成为新规范的一种对称明码算法。全世界的企业和明码学家提交了多个对称明码算法作为 AES 的候选，最终在 2000 年从这些候选算法中选出了一种名为 **Rijndael** 的对称明码算法，并将其确定为了 AES。**Rijndael 的分组长度为 128 比特 **，密钥长度能够以 32 比特为单位在 128 比特到 256 比特的范畴内进行抉择（不过 ** 在 AES 的规格中，密钥长度只有 128、192 和 256 比特三种 **）。- 128bit = 16 字节
- 192bit = 24 字节
- 256bit = 32 字节

> 在 go 提供的接口中秘钥长度只能是 16 字节

#### AES 的加密和解密

和 DES—样，AES 算法也是由多轮所形成的，下图展现了每一轮的大抵计算步骤。DES 应用 Feistel 网络作为其根本构造，而 AES 没有应用 Feistel 网络，而是应用了 SPN Rijndael 的输人分组为 128 比特，也就是 16 字节。首先，须要一一字节地对 16 字节的输出数据进行 SubBytes 解决。所谓 SubBytes, 就是以每个字节的值（0～255 中的任意值）为索引，从一张领有 256 个值的替换表（S-Box）中查找出对应值的解决，也是说，将一个 1 字节的值替换成另一个 1 字节的值。SubBytes 之后须要进行 ShiftRows 解决，行将 SubBytes 的输入以字节为单位进行打乱解决。从下图的线咱们能够看出，这种打乱解决是有法则的。ShiftRows 之后须要进行 MixCo1umns 解决，即对一个 4 字节的值进行比特运算，将其变为另外一个 4 字节值。最初，须要将 MixColumns 的输入与轮密钥进行 XOR，即进行 AddRoundKey 解决。到这里，AES 的一轮就结東了。实际上，在 AES 中须要反复进行 10 ~ 14 轮计算。通过下面的构造咱们能够发现输出的所有比特在一轮中都会被加密。和每一轮都只加密一半输人的比特的 Feistel 网络相比，这种形式的劣势在于加密所须要的轮数更少。此外，这种形式还有一个劣势，即 SubBytes，ShiftRows 和 MixColumns 能够别离按字节、行和列为单位进行并行计算。![](https://user-gold-cdn.xitu.io/2019/9/4/16cfce2a35f5a050?w=551&h=435&f=png&s=95263)

- SubBytes        --     字节代换
- ShiftRows        --    行移位代换
- MixColumns    --    列混同    
- AddRoundKey    --    轮密钥加

下图展现了 AES 中一轮的解密过程。从图中咱们能够看出，SubBytes、ShiftRows、MixColumns 别离存在反向运算 InvSubBytes、InvShiftRows、InvMixColumns，这是因为 AES 不像 Feistel 网络一样可能用同一种构造实现加密和解密。![](https://user-gold-cdn.xitu.io/2019/9/4/16cfce35b59b0c4a?w=574&h=436&f=png&s=93480)

- InvSubBytes        --    逆字节代替
- InvShiftRows        --    逆行移位
- InvMixColumns    --    逆列混同


####  Go 中对 AES 的应用

##### 加解密实现思路

- ** 加密 - CBC 分组模式 **

  > 1. 创立并返回一个应用 AES 算法的 cipher.Block 接口
  >    - ** 秘钥长度为 128bit, 即 128/8 = 16 字节(byte)**
  > 2. 对最初一个明文分组进行数据填充
  >    - AES 是以 128 比特的明文（比特序列）为一个单位来进行加密的
  >    - 最初一组不够 128bit, 则须要进行数据填充(** 参考第三章 **)
  > 3. 创立一个明码分组为链接模式的, 底层应用 AES 加密的 BlockMode 接口
  > 4. 加密间断的数据块

- ** 解密 **

  > 1. 创立并返回一个应用 AES 算法的 cipher.Block 接口
  > 2. 创立一个明码分组为链接模式的, 底层应用 AES 解密的 BlockMode 接口
  > 3. 数据块解密
  > 4. 去掉最初一组的填充数据

##### 加解密的代码实现

AES 加密代码

// AES 加密
func AESEncrypt(src, key []byte) []byte{

// 1. 创立一个应用 AES 加密的块对象
block, err := aes.NewCipher(key)
if err != nil{panic(err)
}
// 2. 最初一个分组进行数据填充
src = PKCS5Padding(src, block.BlockSize())
// 3. 创立一个分组为链接模式, 底层应用 AES 加密的块模型对象
blockMode := cipher.NewCBCEncrypter(block, key[:block.BlockSize()])
// 4. 加密
dst := src
blockMode.CryptBlocks(dst, src)
return dst

}


AES 解密

// AES 解密
func AESDecrypt(src, key []byte) []byte{

// 1. 创立一个应用 AES 解密的块对象
block, err := aes.NewCipher(key)
if err != nil{panic(err)
}
// 2. 创立分组为链接模式, 底层应用 AES 的解密模型对象
blockMode := cipher.NewCBCDecrypter(block, key[:block.BlockSize()])
// 3. 解密
dst := src
blockMode.CryptBlocks(dst, src)
// 4. 去掉尾部填充的字
dst = PKCS5UnPadding(dst)
return dst

}


重要的函数阐明

1. 生成一个底层应用 AES 加 / 解密的 Block 接口对象

函数对应的包: import “crypto/aes”
func NewCipher(key []byte) (cipher.Block, error)

   - 参数 key: aes 对称加密应用的明码, 明码长度为 128bit, 即 16byte
   - 返回值 cipher.Block: 创立出的应用 AES 加 / 解密的 Block 接口对象


2. 创立一个明码分组为 CBC 模式, 底层应用 b 加密的 BlockMode 接口对象

函数对应的包: import “crypto/cipher”
func NewCBCEncrypter(b Block, iv []byte) BlockMode

   - 参数 b: 应用 aes.NewCipher 函数创立出的 Block 接口对象
   - 参数 iv: 当时筹备好的一个长度为一个分组长度的比特序列, 每个分组为 64bit, 即 8byte
   - 返回值: 失去的 BlockMode 接口对象


3. 应用 cipher 包的 BlockMode 接口对象对数据进行加 / 解密

接口对应的包: import “crypto/cipher”
type BlockMode interface {

   // 返回加密字节块的大小
   BlockSize() int
   // 加密或解密间断的数据块，src 的尺寸必须是块大小的整数倍，src 和 dst 可指向同一内存地址
   CryptBlocks(dst, src []byte)

}
接口中的 CryptBlocks(dst, src []byte) 办法:

   - 参数 dst: 传出参数, 存储加密或解密运算之后的后果 
   - 参数 src: 传入参数, 须要进行加密或解密的数据切片(字符串)


4. 创立一个明码分组为 CBC 模式, 底层应用 b 解密的 BlockMode 接口对象

函数对应的包: import “crypto/cipher”
func NewCBCDecrypter(b Block, iv []byte) BlockMode

   - 参数 b: 应用 des.NewCipher 函数创立出的 Block 接口对象
   - 参数 iv: 当时筹备好的一个长度为一个分组长度的比特序列, 每个分组为 128bit, 即 16byte, 
              该序列的值须要和 NewCBCEncrypter 函数的第二个参数 iv 值雷同
   - 返回值: 失去的 BlockMode 接口对象


###  应抉择哪种对称加密

> 后面介绍了 DES、三重 DES 和 AES 等对称明码，那么咱们到底应该应用哪一种对称明码算法呢？>
> 1. ** 今后最好不要将 DES 用于新的用处，因为随着计算机技术的提高，当初用暴力破解法曾经可能在事实的工夫内实现对 DES 的破译。然而，在某些状况下也须要放弃与旧版本软件的兼容性。**
> 2. ** 出于兼容性的因素三重 DES 在今后还会应用一段时间，但会逐步被 AES 所取代。**
> 3. ** 今后大家应该应用的算法是 AES（Rijndael），因为它平安、疾速，而且可能在各种平台上工作。此外，因为全世界的明码学家都在对 AES 进行一直的验证，因而即使万一发现它有什么缺点，也会立即告知全世界并修复这些缺点。**
>
 一般来说，咱们不应该应用任何自制的明码算法，而是应该应用 AES。因为 AES 在其选定过程中，通过了全世界明码学家所进行的高品质的验证工作，而对于自制的明码算法则很难进行这样的验证。欢送与我交换

关于密码学:密码学之对称加密

比特序列密码

DES

加密和解密

Go 中对 DES 的操作

加解密实现思路

加解密的代码实现