golang中的对称加密

概念

1. 按位异或

   • 第一步需要将数据转换为二进制

   • 按位异或操作符: ^

   • 两个标志位进行按位异或操作:

     • 相同为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 按位异或 ===> 解密
     

2. ECB - Electronic Code Book, 电子密码本模式

   • 特点: 简单, 效率高, 密文有规律, 容易被破解
   • 最后一个明文分组必须要填充
     • des/3des -> 最后一个分组填充满8字节
     • aes -> 最后一个分组填充满16字节
   • 不需要初始化向量

3. CBC - Cipher Block Chaining, 密码块链模式

   • 特点: 密文没有规律, 经常使用的加密方式
   • 最后一个明文分组需要填充
     • des/3des -> 最后一个分组填充满8字节
     • aes -> 最后一个分组填充满16字节
   • 需要一个初始化向量 - 一个数组
     • 数组的长度: 与明文分组相等
     • 数据来源: 负责加密的人的提供的
     • 加解密使用的初始化向量值必须相同

4. CFB - Cipher FeedBack, 密文反馈模式

   • 特点: 密文没有规律, 明文分组是和一个数据流进行的按位异或操作, 最终生成了密文
   • 需要一个初始化向量 - 一个数组
     • 数组的长度: 与明文分组相等
     • 数据来源: 负责加密的人的提供的
     • 加解密使用的初始化向量值必须相同
   • 不需要填充

5. OFB - Output-Feedback, 输出反馈模式

   • 特点: 密文没有规律, 明文分组是和一个数据流进行的按位异或操作, 最终生成了密文
   • 需要一个初始化向量 - 一个数组
     • 数组的长度: 与明文分组相等
     • 数据来源: 负责加密的人的提供的
     • 加解密使用的初始化向量值必须相同
   • 不需要填充

6. CTR - CounTeR, 计数器模式

   • 特点: 密文没有规律, 明文分组是和一个数据流进行的按位异或操作, 最终生成了密文
   • 不需要初始化向量
     • go接口中的iv可以理解为随机数种子, iv的长度 == 明文分组的长度
   • 不需要填充

7. 最后一个明文分组的填充

   • 使用cbc, ecb需要填充
     • 要求:
       • 明文分组中进行了填充, 然后加密
       • 解密密文得到明文, 需要把填充的字节删除
   • 使用 ofb, cfb, ctr不需要填充

8. 初始化向量 - IV

   • ecb, ctr模式不需要初始化向量
   • cbc, ofc, cfb需要初始化向量
     • 初始化向量的长度
       • des/3des -> 8字节
       • aes -> 16字节
     • 加解密使用的初始化向量相同

实现

1. des

2. 3des

3. 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 - 推荐使用, 效率最高

标签：cipherText,加密,字节,plainText,des,golang,分组,对称,byte
来源： https://blog.51cto.com/u_15144024/2840177