Golang AES 加密與解密

【導讀】本文介紹了 Go 服務端 AES 加密解密的實現。

RESTful API 設計（Advanced Encryption Standard ,AES）

算法公開、計算量小、加密速度快、加密效率高。

發送方和接收方必須商定好密鑰，然後使雙方都能保存好密鑰，密鑰管理成爲雙方的負擔。

相對大一點的數據量或關鍵數據的加密。

加解密
package helpers

import (
    "bytes"
    "crypto/aes"
    "crypto/cipher"
    "encoding/base64"
    "errors"
)

//加密過程：
//  1、處理數據，對數據進行填充，採用PKCS7（當密鑰長度不夠時，缺幾位補幾個幾）的方式。
//  2、對數據進行加密，採用AES加密方法中CBC加密模式
//  3、對得到的加密數據，進行base64加密，得到字符串
// 解密過程相反

//16,24,32位字符串的話，分別對應AES-128，AES-192，AES-256 加密方法
//key不能泄露
var PwdKey = []byte("ABCDABCDABCDABCD")

//pkcs7Padding 填充
func pkcs7Padding(data []byte, blockSize int) []byte {
    //判斷缺少幾位長度。最少1，最多 blockSize
    padding := blockSize - len(data)%blockSize
    //補足位數。把切片[]byte{byte(padding)}複製padding個
    padText := bytes.Repeat([]byte{byte(padding)}, padding)
    return append(data, padText...)
}

//pkcs7UnPadding 填充的反向操作
func pkcs7UnPadding(data []byte) ([]byte, error) {
    length := len(data)
    if length == 0 {
        return nil, errors.New("加密字符串錯誤！")
    }
    //獲取填充的個數
    unPadding := int(data[length-1])
    return data[:(length - unPadding)], nil
}

//AesEncrypt 加密
func AesEncrypt(data []byte, key []byte) ([]byte, error) {
    //創建加密實例
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }
    //判斷加密快的大小
    blockSize := block.BlockSize()
    //填充
    encryptBytes := pkcs7Padding(data, blockSize)
    //初始化加密數據接收切片
    crypted := make([]byte, len(encryptBytes))
    //使用cbc加密模式
    blockMode := cipher.NewCBCEncrypter(block, key[:blockSize])
    //執行加密
    blockMode.CryptBlocks(crypted, encryptBytes)
    return crypted, nil
}

//AesDecrypt 解密
func AesDecrypt(data []byte, key []byte) ([]byte, error) {
    //創建實例
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }
    //獲取塊的大小
    blockSize := block.BlockSize()
    //使用cbc
    blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])
    //初始化解密數據接收切片
    crypted := make([]byte, len(data))
    //執行解密
    blockMode.CryptBlocks(crypted, data)
    //去除填充
    crypted, err = pkcs7UnPadding(crypted)
    if err != nil {
        return nil, err
    }
    return crypted, nil
}

//EncryptByAes Aes加密 後 base64 再加
func EncryptByAes(data []byte) (string, error) {
    res, err := AesEncrypt(data, PwdKey)
    if err != nil {
        return "", err
    }
    return base64.StdEncoding.EncodeToString(res), nil
}

//DecryptByAes Aes 解密
func DecryptByAes(data string) ([]byte, error) {
    dataByte, err := base64.StdEncoding.DecodeString(data)
    if err != nil {
        return nil, err
    }
    return AesDecrypt(dataByte, PwdKey)
}

使用

func testAes() {
    //加密
    str, _ := helpers.EncryptByAes(data)
    //解密
    str1,_:=helpers.DecryptByAes(str)
    //打印
    fmt.Printf(" 加密：%v\n 解密：%s\n ",
        str,str1,
    )
}
//測試速度
func testAesTime() {
    startTime := time.Now()
    count := 1000000
    for i := 0; i < count; i++ {
        str, _ := helpers.EncryptByAes(data)
        helpers.DecryptByAes(str)
    }
    fmt.Printf("%v次 - %v", count, time.Since(startTime))
}
文件加密解密
// 更新 文件 的加解密

//EncryptFile 文件加密，filePath 需要加密的文件路徑 ，fName加密後文件名
func EncryptFile(filePath, fName string) (err error) {
    f, err := os.Open(filePath)
    if err != nil {
        fmt.Println("未找到文件")
        return
    }
    defer f.Close()

    fInfo, _ := f.Stat()
    fLen := fInfo.Size()
    fmt.Println("待處理文件大小:", fLen)
    maxLen := 1024 * 1024 * 100 //100mb  每 100mb 進行加密一次
    var forNum int64 = 0
    getLen := fLen

    if fLen > int64(maxLen) {
        getLen = int64(maxLen)
        forNum = fLen / int64(maxLen)
        fmt.Println("需要加密次數：", forNum+1)
    }
    //加密後存儲的文件
    ff, err := os.OpenFile("encryptFile_"+fName, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
    if err != nil {
        fmt.Println("文件寫入錯誤")
        return err
    }
    defer ff.Close()
    //循環加密，並寫入文件
    for i := 0; i < int(forNum+1); i++ {
        a := make([]byte, getLen)
        n, err := f.Read(a)
        if err != nil {
            fmt.Println("文件讀取錯誤")
            return err
        }
        getByte, err := EncryptByAes(a[:n])
        if err != nil {
            fmt.Println("加密錯誤")
            return err
        }
        //換行處理，有點亂了，想到更好的再改
        getBytes := append([]byte(getByte), []byte("\n")...)
        //寫入
        buf := bufio.NewWriter(ff)
        buf.WriteString(string(getBytes[:]))
        buf.Flush()
    }
    ffInfo, _ := ff.Stat()
    fmt.Printf("文件加密成功，生成文件名爲：%s，文件大小爲：%v Byte \n", ffInfo.Name(), ffInfo.Size())
    return nil
}

//DecryptFile 文件解密
func DecryptFile(filePath, fName string) (err error) {
    f, err := os.Open(filePath)
    if err != nil {
        fmt.Println("未找到文件")
        return
    }
    defer f.Close()
    fInfo, _ := f.Stat()
    fmt.Println("待處理文件大小:", fInfo.Size())

    br := bufio.NewReader(f)
    ff, err := os.OpenFile("decryptFile_"+fName, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
    if err != nil {
        fmt.Println("文件寫入錯誤")
        return err
    }
    defer ff.Close()
    num := 0
    //逐行讀取密文，進行解密，寫入文件
    for {
        num = num + 1
        a, err := br.ReadString('\n')
        if err != nil {
            break
        }
        getByte, err := DecryptByAes(a)
        if err != nil {
            fmt.Println("解密錯誤")
            return err
        }

        buf := bufio.NewWriter(ff)
        buf.Write(getByte)
        buf.Flush()
    }
    fmt.Println("解密次數：", num)
    ffInfo, _ := ff.Stat()
    fmt.Printf("文件解密成功，生成文件名爲：%s，文件大小爲：%v Byte \n", ffInfo.Name(), ffInfo.Size())
    return
}

// 文件加解密使用，放到 main 函數中。

startTime := time.Now()
//helpers.EncryptFile("qtest.txt","test")
helpers.DecryptFile("encryptFile_test","qtest.txt")
fmt.Printf("耗時：%v", time.Since(startTime))
說明

待處理文件大小: 4208311808
需要加密次數：41
文件加密成功，生成文件名爲：encryptFile_test，文件大小爲：5611083381
耗時：20.484283978s

待處理文件大小: 5611083381
解密次數：42
文件解密成功，生成文件名爲：decryptFile_qtest.txt，文件大小爲：4208311808 Byte
耗時：15.085721748s

關於超大文本的加解密，有兩個思路
  1. 單行超大文本
  1. 非單行
  1. 解密：逐行讀取解密文件，每一行爲一個密文字串，將其解密，寫入到文本中。

轉自：

jianshu.com/p/0caab60fea9f

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/ZWluQVP2VM0BFOPrtt4vRA

猜你喜歡