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

關於AES cbc的加密 在go AES 加密 和解密已經調到了， 此次主要涉及的內同時cbc 和ecb，恰好網上也有相應的說明， 我就一塊兒整理一下

DES是以64比特的明文爲一個單位來進行加密，並生成64比特的密文。因爲它每次只能處理特定長度的一塊數據，因此DES屬於分組密碼算法。cypto/des包提供了有關des加密的功能。

模式

因爲分組密碼算法只能加密固定長度的分組，因此當加密的明文超過度組密碼的長度時，就須要對分組密碼算法進行迭代，而迭代的方法就稱爲分組密碼的模式。模式主要有ECB(電子密碼本)、CBC(密碼分組連接模式)、CTR(計數器模式)、OFB(輸出反饋模式)、CFB(密碼反饋模式)五種。下面簡單介紹下前兩種：

1. ECB(electronic code book)是最簡單的方式，它將明文分組加密後的結果直接成爲密文分組。
   優缺點：模式操做簡單；明文中的重複內容將在密文中表現出來，特別對於圖像數據和明文變化較少的數據；適於短報文的加密傳遞。

2. CBC(cipher block chaining)的原理是加密算法的輸入是當前的明文分組和前一密文分組的異或，第一個明文分組和一個初始向量進行異或，這樣同一個明文分組重複出現時會產生不一樣的密文分組。
   特色：同一個明文分組重複出現時產生不一樣的密文分組；加密函數的輸入是當前的明文分組和前一個密文分組的異或；每一個明文分組的加密函數的輸入與明文分組之間再也不有固定的關係；適合加密長消息。

填充方式

在按8個字節對DES進行加密或解密時，若是最後一段字節不足8位，就須要對數據進行補位。即便加密或解密的數據恰好是8的倍數時，也會再補8位。舉個栗子，若是末尾恰好出現1，這時你就沒法判斷這個1是原來數據，仍是通過補位獲得的1。所以，能夠再補8位進行標識。填充方式主要有如下幾種：pkcs7padding、pkcs5padding、zeropadding、iso1012六、ansix923。

1. pkcs7padding和pkcs5padding的填充方式相同，填充字節的值都等於填充字節的個數。例如須要填充4個字節，則填充的值爲"4 4 4 4"。
2. 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)
}