概念
- 按位异或
- 第一步需要将数据转换为二进制
- 按位异或操作符: ^
- 两个标志位进行按位异或操作:
- 相同为0, 不同为1
- 举例:
1 0 0 0----> 8 1 0 1 1----> 11 -----------------------按位异或一次 0 0 1 1---->3 1 0 1 1----> 11 -----------------------按位异或两侧 1 0 0 0-----> 8 ================================= a = 8 b = 11 a 和 b按位异或1次 ==> 加密 得到的结果再次和 b 按位异或 ===> 解密
- 第一步需要将数据转换为二进制
- ECB - Electronic Code Book, 电子密码本模式
- 特点: 简单, 效率高, 密文有规律, 容易被破解
- 最后一个明文分组必须要填充
- des/3des -> 最后一个分组填充满8字节
- aes -> 最后一个分组填充满16字节
- 不需要初始化向量
- 【golang中的对称加密】CBC - Cipher Block Chaining, 密码块链模式
- 特点: 密文没有规律, 经常使用的加密方式
- 最后一个明文分组需要填充
- des/3des -> 最后一个分组填充满8字节
- aes -> 最后一个分组填充满16字节
- 需要一个初始化向量 - 一个数组
- 数组的长度: 与明文分组相等
- 数据来源: 负责加密的人的提供的
- 加解密使用的初始化向量值必须相同
- CFB - Cipher FeedBack, 密文反馈模式
- 特点: 密文没有规律, 明文分组是和一个数据流进行的按位异或操作, 最终生成了密文
- 需要一个初始化向量 - 一个数组
- 数组的长度: 与明文分组相等
- 数据来源: 负责加密的人的提供的
- 加解密使用的初始化向量值必须相同
- 不需要填充
- OFB - Output-Feedback, 输出反馈模式
- 特点: 密文没有规律, 明文分组是和一个数据流进行的按位异或操作, 最终生成了密文
- 需要一个初始化向量 - 一个数组
- 数组的长度: 与明文分组相等
- 数据来源: 负责加密的人的提供的
- 加解密使用的初始化向量值必须相同
- 不需要填充
- CTR - CounTeR, 计数器模式
- 特点: 密文没有规律, 明文分组是和一个数据流进行的按位异或操作, 最终生成了密文
- 不需要初始化向量
- go接口中的iv可以理解为随机数种子, iv的长度 == 明文分组的长度
- 不需要填充
- 最后一个明文分组的填充
- 使用cbc, ecb需要填充
- 要求:
- 明文分组中进行了填充, 然后加密
- 解密密文得到明文, 需要把填充的字节删除
- 要求:
- 使用 ofb, cfb, ctr不需要填充
- 使用cbc, ecb需要填充
- 初始化向量 - IV
- ecb, ctr模式不需要初始化向量
- cbc, ofc, cfb需要初始化向量
- 初始化向量的长度
- des/3des -> 8字节
- aes -> 16字节
- 加解密使用的初始化向量相同
- 初始化向量的长度
- des
- 3des
- aes
# 加密流程:
1. 创建一个底层使用des/3des/aes的密码接口
"crypto/des"
func NewCipher(key []byte) (cipher.Block, error) # -- des
func NewTripleDESCipher(key []byte) (cipher.Block, error) # -- 3des
"crypto/aes"
func NewCipher(key []byte) (cipher.Block, error) # == aes
2. 如果使用的是cbc/ecb分组模式需要对明文分组进行填充
3. 创建一个密码分组模式的接口对象
- cbc
func NewCBCEncrypter(b Block, iv []byte) BlockMode # 加密
- cfb
func NewCFBEncrypter(block Block, iv []byte) Stream # 加密
- ofb
- ctr
4. 加密, 得到密文
import (
"bytes"
"crypto/aes"
"crypto/cipher"
"crypto/des"
"fmt"
)//des的CBC加密
//编写填充函数,如果最后一个分组字节不够,填充
//...字节数刚好合适,添加一个新分组
//填充个的字节的值==缺少的字节数
func paddingLastGroup(plainText []byte, bloclsize int) []byte {
//1. 求出最后一个组中剩余的字节数
padNum := bloclsize - (len(plainText) % bloclsize)
//2. 创建一个新的切片, 长度==padNum, 每个字节值byte(padNum)
char := []byte{byte(padNum)} //切片长度是1
//切片创建并且重复多少次
newPlain := bytes.Repeat(char, padNum)
//3. newPlain数组追加到原始明文的后面
newText := append(plainText, newPlain...)
return newText
}//去掉填充的数据
func unPaddingLastGrooup(plainText []byte) []byte {
//1. 拿去切片中的最后一个字节
length := len(plainText)
lastChar := plainText[length-1]
number := int(lastChar) //尾部填充的字节数
return plainText[:length-number]
}//des加密
func desEncrypt(plainText, key []byte) []byte {
//1. 建一个底层使用des的密码接口
block, err := des.NewCipher(key)
if err != nil {
panic(err)
}
//2. 明文填充
newText := paddingLastGroup(plainText, block.BlockSize())
//3. 创建一个使用cbc分组接口
iv := []byte("12345678")//8字节
blockMode := cipher.NewCBCEncrypter(block, iv)
//4. 加密
cipherText := make([]byte, len(newText))
blockMode.CryptBlocks(cipherText, newText)
//也可以这样,他加密过会把newText的值覆盖过去,然后返回newText就可以
//blockMode.CryptBlocks(newText, newText)
return cipherText
}// des解密
func desDecrypt(cipherText, key []byte) []byte {
// 1. 建一个底层使用des的密码接口
block, err := des.NewCipher(key)
if err != nil {
panic(err)
}
// 2. 创建一个使用cbc模式解密的接口
iv := []byte("12345678")
blockMode := cipher.NewCBCDecrypter(block, iv)
// 3. 解密
blockMode.CryptBlocks(cipherText, cipherText)
// 4. cipherText现在存储的是明文, 需要删除加密时候填充的尾部数据
plainText := unPaddingLastGrooup(cipherText)
return plainText
}// aes加密, 分组模式ctr
func aesEncrypt(plainText, key []byte) []byte {
// 1. 建一个底层使用aes的密码接口
block, err := aes.NewCipher(key)
if err != nil {
panic(err)
}
// 2. 创建一个使用ctr分组接口
iv := []byte("12345678WHZdefgh")
stream := cipher.NewCTR(block, iv)// 4. 加密
cipherText := make([]byte, len(plainText))
stream.XORKeyStream(cipherText, plainText)return cipherText
}// des解密
func aesDecrypt(cipherText, key []byte) []byte {
// 1. 建一个底层使用des的密码接口
block, err := aes.NewCipher(key)
if err != nil {
panic(err)
}
// 2. 创建一个使用ctr模式解密的接口
iv := []byte("12345678WHZdefgh")
stream := cipher.NewCTR(block, iv)
// 3. 解密
stream.XORKeyStream(cipherText, cipherText)return cipherText
}//测试文件
func main() {
fmt.Println("des 加解密")
key := []byte("1234abEd")
src := []byte("特点: 密文没有规律,明文分组是和一个数据流进行的按位异或操作, 最终生成了密文")
cipherText := desEncrypt(src, key)
plainText := desDecrypt(cipherText, key)
fmt.Printf("解密之后的数据: %s\n", string(plainText))fmt.Println("aes 加解密 ctr模式 ... ")
key1 := []byte("1234abdd12345678")
cipherText = aesEncrypt(src, key1)
plainText = aesDecrypt(cipherText, key1)
fmt.Printf("解密之后的数据: %s\n", string(plainText))
}
总结
- 对称加密中的公开的加密算法
- des
- 分组长度: 8字节
- 秘钥长度: 8字节
- 3des
- 分组长度: 8字节
- 秘钥长度: 24byte
- aes
- 分组长度: 16字节
- 秘钥长度: 16字节, 24字节, 32字节
- 在go的api中只能使用16字节
- 对称加密的分组模式
- EBC - 不推荐使用
- CBC - 常用的方式
- 准备的数据:
- 初始化向量iv - 字符数组
- 长度 == 明文分组长度
- 加解密初始化向量值必须相同
- 秘钥
- 根据加密算法定
- 准备的数据:
- OFB - 不推荐使用
- CFB - 不推荐使用
- CTR - 推荐使用, 效率最高
- EBC - 不推荐使用
- des
推荐阅读
- GoLang底层|GoLang之Go1.17泛型
- golang|golang泛型介绍
- Go|Go语言泛型工具go2go
- golang|Go 泛型
- Golang|Go 1.18 泛型详解: 从零读懂泛型
- golang|Go 泛型的使用
- GO语言|Go1.8 泛型简单上手使用
- golang|Go1.18版本泛型详解
- GO学习笔记|go泛型使用方法