go CBC 加密【AES 和DES的运用】

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› Go›Go教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

关于AES cbc的加密在go AES 加密和解密已经调到了，这次主要涉及的内同时cbc 和ecb，刚好网上也有相应的说明，我就一起整理一下

DES是以64比特的明文为一个单位来进行加密，并生成64比特的密文。由于它每次只能处理特定长度的一块数据，所以DES属于分组密码算法。cypto/des包提供了有关des加密的功能。

模式

由于分组密码算法只能加密固定长度的分组，所以当加密的明文超过分组密码的长度时，就需要对分组密码算法进行迭代，而迭代的方法就称为分组密码的模式。模式主要有ECB(电子密码本)、CBC(密码分组链接模式)、CTR(计数器模式)、OFB(输出反馈模式)、CFB(密码反馈模式)五种。下面简单介绍下前两种：

ECB(electronic code book)是最简单的方式，它将明文分组加密后的结果直接成为密文分组。
优缺点：模式操作简单；明文中的重复内容将在密文中表现出来，特别对于图像数据和明文变化较少的数据；适于短报文的加密传递。
CBC(cipher block chaining)的原理是加密算法的输入是当前的明文分组和前一密文分组的异或，第一个明文分组和一个初始向量进行异或，这样同一个明文分组重复出现时会产生不同的密文分组。
特点：同一个明文分组重复出现时产生不同的密文分组；加密函数的输入是当前的明文分组和前一个密文分组的异或；每个明文分组的加密函数的输入与明文分组之间不再有固定的关系；适合加密长消息。

填充方式

在按8个字节对DES进行加密或解密时，如果最后一段字节不足8位，就需要对数据进行补位。即使加密或解密的数据刚好是8的倍数时，也会再补8位。举个栗子，如果末尾刚好出现1，这时你就无法判断这个1是原来数据，还是经过补位得到的1。因此，可以再补8位进行标识。填充方式主要有以下几种：pkcs7padding、pkcs5padding、zeropadding、iso10126、ansix923。

pkcs7padding和pkcs5padding的填充方式相同，填充字节的值都等于填充字节的个数。例如需要填充4个字节，则填充的值为"4 4 4 4"。
zeropadding填充字节的值都为0。

密码

DES的密钥长度是64比特，但由于每隔7个比特会设置一个用于错误检测的比特，因此其实质密钥长度为56比特。

偏移量

上面模式中，例如CBC，再加密第一个明文分组时，由于不存在“前一个密文分组”，因此需要事先准备一个长度为一个分组的比特序列来代替“前一个密文分组”，这个比特序列成为初始化向量，也称偏移量，通常缩写为IV。一般来说，每次加密时都会随机产生一个不同的比特序列来作为初始化向量。偏移量的长度必须和块的大小相同。

输出

加密后的字节在显示时可以进行hex和base64编码，hex是十六进制编码，base64是一种基于64个可打印字符来标识二进制数据的方法。

下面以上面提到的几种模式和填充方式为例，进行演示如何在代码中使用。

加密模式采用ECB、填充方式采用pkcs5padding、密码使用"12345678",输出时经hex编码。自己可以通过一些在线测试工具进行测试，看结果是否一致。

一定要注意DES CBC的key长度为8， AES CBC 的key 为16，24,32

package utils
 
import (
    "bytes"
    "crypto/aes"
    "crypto/cipher"
    "crypto/des"
    "encoding/hex"
    "fmt"
)
 
/*
DES CBC加密
key的长度为8个字节， iv必须相同长度
*/
func EncryptDES_CBC(src, key, iv string) string {
    data := []byte(src)
    keyByte := []byte(key)
    block, err := des.NewCipher(keyByte)
    if err != nil {
        panic(err)
    }
    data = PKCS5Padding(data, block.BlockSize())
    //获取CBC加密模式
    //iv := keyByte //用密钥作为向量(不建议这样使用)
    ivByte := []byte(iv)
    mode := cipher.NewCBCEncrypter(block, ivByte)
    out := make([]byte, len(data))
    mode.CryptBlocks(out, data)
    return fmt.Sprintf("%X", out)
}
 
//DESC CBC解密
func DecryptDES_CBC(src, key, iv string) string {
    keyByte := []byte(key)
    data, err := hex.DecodeString(src)
    if err != nil {
        panic(err)
    }
    block, err := des.NewCipher(keyByte)
    if err != nil {
        panic(err)
    }
    ivBye := []byte(iv)
    mode := cipher.NewCBCDecrypter(block, ivBye)
    plaintext := make([]byte, len(data))
    mode.CryptBlocks(plaintext, data)
    plaintext = PKCS5UnPadding(plaintext)
    return string(plaintext)
}
 
//ECB加密
func EncryptDES_ECB(src, key string) string {
    data := []byte(src)
    keyByte := []byte(key)
    block, err := des.NewCipher(keyByte)
    if err != nil {
        panic(err)
    }
    bs := block.BlockSize()
    //对明文数据进行补码
    data = PKCS5Padding(data, bs)
    if len(data)%bs != 0 {
        panic("Need a multiple of the blocksize")
    }
    out := make([]byte, len(data))
    dst := out
    for len(data) > 0 {
        //对明文按照blocksize进行分块加密
        //必要时可以使用go关键字进行并行加密
        block.Encrypt(dst, data[:bs])
        data = data[bs:]
        dst = dst[bs:]
    }
    return fmt.Sprintf("%X", out)
}
 
//ECB解密
func DecryptDES_ECB(src, key string) string {
    data, err := hex.DecodeString(src)
    if err != nil {
        panic(err)
    }
    keyByte := []byte(key)
    block, err := des.NewCipher(keyByte)
    if err != nil {
        panic(err)
    }
    bs := block.BlockSize()
    if len(data)%bs != 0 {
        panic("crypto/cipher: input not full blocks")
    }
    out := make([]byte, len(data))
    dst := out
    for len(data) > 0 {
        block.Decrypt(dst, data[:bs])
        data = data[bs:]
        dst = dst[bs:]
    }
    out = PKCS5UnPadding(out)
    return string(out)
}
 
/*
    key参数的长度 iv必须相同长度
    16 字节 - AES-128
    24 字节 - AES-192
    32 字节 - AES-256
*/
func EncryptAES_CBC(src, key, iv string) string {
    data := []byte(src)
    keyByte := []byte(key)
    block, err := aes.NewCipher(keyByte)
    if err != nil {
        panic(err)
    }
    data = PKCS5Padding(data, block.BlockSize())
    //获取CBC加密模式
    //iv := keyByte //用密钥作为向量(不建议这样使用)
    ivByte := []byte(iv)
    mode := cipher.NewCBCEncrypter(block, ivByte)
    out := make([]byte, len(data))
    mode.CryptBlocks(out, data)
    return fmt.Sprintf("%X", out)
}
 
//AES CBC解密
func DecryptAES_CBC(src, key, iv string) string {
    keyByte := []byte(key)
    data, err := hex.DecodeString(src)
    if err != nil {
        panic(err)
    }
    block, err := aes.NewCipher(keyByte)
    if err != nil {
        panic(err)
    }
    //iv := keyByte //用密钥作为向量(不建议这样使用)
    ivBye := []byte(iv)
    mode := cipher.NewCBCDecrypter(block, ivBye)
    plaintext := make([]byte, len(data))
    mode.CryptBlocks(plaintext, data)
    plaintext = PKCS5UnPadding(plaintext)
    return string(plaintext)
}
 
//明文补码算法
func PKCS5Padding(ciphertext []byte, blockSize int) []byte {
    padding := blockSize - len(ciphertext)%blockSize
    padtext := bytes.Repeat([]byte{byte(padding)}, padding)
    return append(ciphertext, padtext...)
}
 
//明文减码算法
func PKCS5UnPadding(origData []byte) []byte {
    length := len(origData)
    unpadding := int(origData[length-1])
    return origData[:(length - unpadding)]
}

第三方包

github.com/marspere/goencrypt包实现了多种加密算法，包括对称加密和非对称加密等。

package main
 
import (
    "fmt"
 
    "github.com/marspere/goencrypt"
)
 
func main() {
    // key为12345678
    // iv为空
    // 采用ECB分组模式
    // 采用pkcs7padding填充模式
    // 输出结果使用base64进行加密
    cipher := goencrypt.NewDESCipher([]byte("12345678"), []byte(""), goencrypt.ECBMode, goencrypt.Pkcs7, goencrypt.PrintBase64)
    cipherText, err := cipher.DESEncrypt([]byte("hello world"))
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(cipherText)
    plainText, err := cipher.DESDecrypt(cipherText)
    fmt.Println(plainText)
}

---------------------2021-4-21-------------

import (
   "bytes"
   "crypto/aes"
   "crypto/cipher"
)

// PKCS7加填充/和PKCS5填充一样,只是填充字段多少的区别
func PKCS7Padding(cipherText []byte, blockSize int) []byte {
   padding := blockSize - len(cipherText)%blockSize
   padText := bytes.Repeat([]byte{byte(padding)}, padding)
   return append(cipherText, padText...)
}

// PKCS7解填充/和PKCS5填充一样,只是填充字段多少的区别
func PKCS7UnPadding(encrypt []byte) []byte {
   length := len(encrypt)
   unPadding := int(encrypt[length-1])
   return encrypt[:(length - unPadding)]
}

// AES/ECB/PKCS7模式加密--签名加密方式
func AesECBEncrypt(data, key []byte) ([]byte, error) {
   block, err := aes.NewCipher(key)
   if err != nil {
      return []byte{}, err
   }
   ecb := NewECBEncryptEr(block)
   // 加PKCS7填充
   content := PKCS7Padding(data, block.BlockSize())
   encryptData := make([]byte, len(content))
   // 生成加密数据
   ecb.CryptBlocks(encryptData, content)
   return encryptData, nil
}

// AES/ECB/PKCS7模式解密--签名解密方式
func AesECBDecrypt(data, key []byte) ([]byte, error) {
   block, err := aes.NewCipher(key)
   if err != nil {
      return []byte{}, err
   }
   ecb := NewECBDecryptEr(block)
   retData := make([]byte, len(data))
   ecb.CryptBlocks(retData, data)
   // 解PKCS7填充
   retData = PKCS7UnPadding(retData)
   return retData, nil
}



type ecb struct {
   b         cipher.Block
   blockSize int
}

func newECB(b cipher.Block) *ecb {
   return &ecb{
      b:         b,
      blockSize: b.BlockSize(),
   }
}

type ecbEncryptEr ecb

func NewECBEncryptEr(b cipher.Block) cipher.BlockMode {
   return (*ecbEncryptEr)(newECB(b))
}

func (x *ecbEncryptEr) BlockSize() int { return x.blockSize }

func (x *ecbEncryptEr) CryptBlocks(dst, src []byte) {
   if len(src)%x.blockSize != 0 {
      panic("crypto/cipher: input not full blocks")
   }
   if len(dst) < len(src) {
      panic("crypto/cipher: output smaller than input")
   }
   for len(src) > 0 {
      x.b.Encrypt(dst, src[:x.blockSize])
      src = src[x.blockSize:]
      dst = dst[x.blockSize:]
   }
}

// ecb解密方法
type ecbDecryptEr ecb

func NewECBDecryptEr(b cipher.Block) cipher.BlockMode {
   return (*ecbDecryptEr)(newECB(b))
}

func (x *ecbDecryptEr) BlockSize() int { return x.blockSize }

func (x *ecbDecryptEr) CryptBlocks(dst, src []byte) {
   if len(src)%x.blockSize != 0 {
      panic("crypto/cipher: input not full blocks")
   }
   if len(dst) < len(src) {
      panic("crypto/cipher: output smaller than input")
   }
   for len(src) > 0 {
      x.b.Decrypt(dst, src[:x.blockSize])
      src = src[x.blockSize:]
      dst = dst[x.blockSize:]
   }
}

java实现：

public static String encode(String reqstr, String reqkey) throws Exception {
    Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding", "BC");
    SecretKeySpec keySpec = new SecretKeySpec(reqkey.getBytes("UTF-8"), "AES");
    cipher.init(1, keySpec);
    byte[] result = cipher.doFinal(reqstr.getBytes("UTF-8"));
    return new String(Base64.encode(result));
}
public static String decodeByAES(String reskey, String resstr) throws Exception {
    byte[] responseByte = Base64.decode(resstr);
    Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding", "BC");
    SecretKeySpec keySpec = new SecretKeySpec(hex2bytes(reskey), "AES");
    cipher.init(2, keySpec);
    byte[] decoded = cipher.doFinal(responseByte);
    return new String(decoded, "UTF-8");
}