共计 11037 个字符，预计需要花费 28 分钟才能阅读完成。
- 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
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 的加密与解密 – 图例
Go 中对 DES 的操作
加解密实现思路
-
加密 – CBC 分组模式
-
创立并返回一个应用 DES 算法的 cipher.Block 接口
- 秘钥长度为 64bit, 即 64/8 = 8 字节(byte)
-
对最初一个明文分组进行数据填充
- DES 是以 64 比特的明文（比特序列）为一个单位来进行加密的
- 最初一组不够 64bit, 则须要进行数据填充 ( 参考第三章)
- 创立一个明码分组为链接模式的, 底层应用 DES 加密的 BlockMode 接口
- 加密间断的数据块
-
-
解密
- 创立并返回一个应用 DES 算法的 cipher.Block 接口
- 创立一个明码分组为链接模式的, 底层应用 DES 解密的 BlockMode 接口
- 数据块解密
- 去掉最初一组的填充数据
加解密的代码实现
在 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
)
明文通过三次 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 能够别离按字节、行和列为单位进行并行计算。
- SubBytes -- 字节代换
- ShiftRows -- 行移位代换
- MixColumns -- 列混同
- AddRoundKey -- 轮密钥加
下图展现了 AES 中一轮的解密过程。从图中咱们能够看出，SubBytes、ShiftRows、MixColumns 别离存在反向运算 InvSubBytes、InvShiftRows、InvMixColumns，这是因为 AES 不像 Feistel 网络一样可能用同一种构造实现加密和解密。
- 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 在其选定过程中，通过了全世界明码学家所进行的高品质的验证工作，而对于自制的明码算法则很难进行这样的验证。欢送与我交换