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

上一篇:加密解密概念和作用;字符编码;Base64编码原理;三种加密方式:单向加密(MD5,SHA,对称加密(讲解DES,3DES,AES),非对称加密(讲解RSA);


下一篇:密码学待解决问题