标签：cipherText 加密 字节 plainText des golang 分组 对称 byte

概念

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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。