golang中的对称加密 golang

概念

按位异或
- 第一步需要将数据转换为二进制
- 按位异或操作符: ^
- 两个标志位进行按位异或操作:
  - 相同为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不需要填充
初始化向量 - 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 - 推荐使用, 效率最高