Go加密演算法總結
阿新 • • 發佈：2020-12-19
#### 前言
> 加密解密在實際開發中應用比較廣泛，常用加解密分為：“**對稱式**”、“**非對稱式**”和”**數字簽名**“。
>
> **對稱式**：對稱加密(也叫[私鑰](https://baike.baidu.com/item/私鑰)加密)指加密和解密使用相同[金鑰](https://baike.baidu.com/item/金鑰)的加密演算法。具體演算法主要有[DES演算法](https://baike.baidu.com/item/DES演算法)，[3DES](https://baike.baidu.com/item/3DES)演算法，TDEA演算法，[Blowfish](https://baike.baidu.com/item/Blowfish)演算法，[RC5](https://baike.baidu.com/item/RC5)演算法，[IDEA](https://baike.baidu.com/item/IDEA)演算法。
>
> **非對稱加密(公鑰加密)**：指加密和解密使用不同[金鑰](https://baike.baidu.com/item/金鑰)的加密演算法，也稱為公[私鑰](https://baike.baidu.com/item/私鑰)加密。具體演算法主要有[RSA](https://baike.baidu.com/item/RSA)、[Elgamal](https://baike.baidu.com/item/Elgamal)、揹包演算法、Rabin、D-H、[ECC](https://baike.baidu.com/item/ECC)（橢圓曲線加密演算法）。
>
> 數字簽名：數字簽名是非對稱[金鑰加密技術](https://baike.baidu.com/item/金鑰加密技術)與[數字摘要](https://baike.baidu.com/item/數字摘要/4069118)技術的應用。主要演算法有md5、hmac、sha1等。
>
> 以下介紹golang語言主要的加密解密演算法實現。
#### md5
> **MD5資訊摘要演算法**是一種被廣泛使用的[密碼雜湊函式](https://baike.baidu.com/item/密碼雜湊函式/14937715)，可以產生出一個128位（16進位制，32個字元）的雜湊值（hash value），用於確保資訊傳輸完整一致。
```go
func GetMd5String(s string) string {
h := md5.New()
h.Write([]byte(s))
return hex.EncodeToString(h.Sum(nil))
}
```
#### hmac
> HMAC是金鑰相關的雜湊運算訊息認證碼（Hash-based Message Authentication Code）的縮寫，
>
> 它通過一個標準演算法，在計算雜湊的過程中，把key混入計算過程中。
>
> 和我們自定義的加salt演算法不同，Hmac演算法針對所有雜湊演算法都通用，無論是MD5還是SHA-1。採用Hmac替代我們自己的salt演算法，可以使程式演算法更標準化，也更安全。
```go
//key隨意設定 data 要加密資料
func Hmac(key, data string) string {
hash:= hmac.New(md5.New, []byte(key)) // 建立對應的md5雜湊加密演算法
hash.Write([]byte(data))
return hex.EncodeToString(hash.Sum([]byte("")))
}
func HmacSha256(key, data string) string {
hash:= hmac.New(sha256.New, []byte(key)) //建立對應的sha256雜湊加密演算法
hash.Write([]byte(data))
return hex.EncodeToString(hash.Sum([]byte("")))
}
```
#### sha1
> SHA-1可以生成一個被稱為訊息摘要的160[位](https://baike.baidu.com/item/位)（20[位元組](https://baike.baidu.com/item/位元組)）雜湊值，雜湊值通常的呈現形式為40個[十六進位制](https://baike.baidu.com/item/十六進位制/4162457)數。
```go
func Sha1(data string) string {
sha1 := sha1.New()
sha1.Write([]byte(data))
return hex.EncodeToString(sha1.Sum([]byte("")))
}
```
##### Crypto加密
```go
package main
import (
"fmt"
"golang.org/x/crypto/bcrypt"
)
func main() {
password := "test"
hash,err := bcrypt.GenerateFromPassword([]byte(password),0)
fmt.Println(string(hash),err)
// 密碼如果校驗成功會返回Nil
fmt.Println(bcrypt.CompareHashAndPassword(hash,[]byte("youmen18")))
}
```
#### AES
> 密碼學中的高階加密標準（Advanced Encryption Standard，AES），又稱Rijndael[加密法](https://baike.baidu.com/item/加密法)，是美國聯邦政府採用的一種區塊加密標準。這個標準用來替代原先的[DES](https://baike.baidu.com/item/DES)（Data Encryption Standard），已經被多方分析且廣為全世界所使用。AES中常見的有三種解決方案，分別為AES-128、AES-192和AES-256。如果採用真正的128位加密技術甚至256位加密技術，蠻力攻擊要取得成功需要耗費相當長的時間。
`AES有五種加密模式`
```go
/*
電碼本模式（Electronic Codebook Book (ECB)）、
密碼分組連結模式（Cipher Block Chaining (CBC)）、
計算器模式（Counter (CTR)）、
密碼反饋模式（Cipher FeedBack (CFB)）
輸出反饋模式（Output FeedBack (OFB)）
*/
```
##### ECB模式
`出於安全考慮，golang預設並不支援ECB模式。`
```go
package main
import (
"crypto/aes"
"fmt"
)
func AESEncrypt(src []byte, key []byte) (encrypted []byte) {
cipher, _ := aes.NewCipher(generateKey(key))
length := (len(src) + aes.BlockSize) / aes.BlockSize
plain := make([]byte, length*aes.BlockSize)
copy(plain, src)
pad := byte(len(plain) - len(src))
for i := len(src); i < len(plain); i++ {
plain[i] = pad
}
encrypted = make([]byte, len(plain))
// 分組分塊加密
for bs, be := 0, cipher.BlockSize(); bs <= len(src); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
cipher.Encrypt(encrypted[bs:be], plain[bs:be])
}
return encrypted
}
func AESDecrypt(encrypted []byte, key []byte) (decrypted []byte) {
cipher, _ := aes.NewCipher(generateKey(key))
decrypted = make([]byte, len(encrypted))
//
for bs, be := 0, cipher.BlockSize(); bs < len(encrypted); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
cipher.Decrypt(decrypted[bs:be], encrypted[bs:be])
}
trim := 0
if len(decrypted) > 0 {
trim = len(decrypted) - int(decrypted[len(decrypted)-1])
}
return decrypted[:trim]
}
func generateKey(key []byte) (genKey []byte) {
genKey = make([]byte, 16)
copy(genKey, key)
for i := 16; i < len(key); {
for j := 0; j < 16 && i < len(key); j, i = j+1, i+1 {
genKey[j] ^= key[i]
}
}
return genKey
}
func main() {
source:="hello world"
fmt.Println("原字元：",source)
//16byte金鑰
key:="1443flfsaWfdas"
encryptCode:=AESEncrypt([]byte(source),[]byte(key))
fmt.Println("密文：",string(encryptCode))
decryptCode:=AESDecrypt(encryptCode,[]byte(key))
fmt.Println("解密：",string(decryptCode))
}
```
##### CBC模式
```go
package main
import(
"bytes"
"crypto/aes"
"fmt"
"crypto/cipher"
"encoding/base64"
)
func main() {
orig := "hello world"
key := "0123456789012345"
fmt.Println("原文：", orig)
encryptCode := AesEncrypt(orig, key)
fmt.Println("密文：" , encryptCode)
decryptCode := AesDecrypt(encryptCode, key)
fmt.Println("解密結果：", decryptCode)
}
func AesEncrypt(orig string, key string) string {
// 轉成位元組陣列
origData := []byte(orig)
k := []byte(key)
// 分組祕鑰
// NewCipher該函式限制了輸入k的長度必須為16, 24或者32
block, _ := aes.NewCipher(k)
// 獲取祕鑰塊的長度
blockSize := block.BlockSize()
// 補全碼
origData = PKCS7Padding(origData, blockSize)
// 加密模式
blockMode := cipher.NewCBCEncrypter(block, k[:blockSize])
// 建立陣列
cryted := make([]byte, len(origData))
// 加密
blockMode.CryptBlocks(cryted, origData)
return base64.StdEncoding.EncodeToString(cryted)
}
func AesDecrypt(cryted string, key string) string {
// 轉成位元組陣列
crytedByte, _ := base64.StdEncoding.DecodeString(cryted)
k := []byte(key)
// 分組祕鑰
block, _ := aes.NewCipher(k)
// 獲取祕鑰塊的長度
blockSize := block.BlockSize()
// 加密模式
blockMode := cipher.NewCBCDecrypter(block, k[:blockSize])
// 建立陣列
orig := make([]byte, len(crytedByte))
// 解密
blockMode.CryptBlocks(orig, crytedByte)
// 去補全碼
orig = PKCS7UnPadding(orig)
return string(orig)
}
//補碼
//AES加密資料塊分組長度必須為128bit(byte[16])，金鑰長度可以是128bit(byte[16])、192bit(byte[24])、256bit(byte[32])中的任意一個。
func PKCS7Padding(ciphertext []byte, blocksize int) []byte {
padding := blocksize - len(ciphertext)%blocksize
padtext := bytes.Repeat([]byte{byte(padding)}, padding)
return append(ciphertext, padtext...)
}
//去碼
func PKCS7UnPadding(origData []byte) []byte {
length := len(origData)
unpadding := int(origData[length-1])
return origData[:(length - unpadding)]
}
```
##### CRT模式
```go
package main
import (
"bytes"
"crypto/aes"
"crypto/cipher"
"fmt"
)
//加密
func aesCtrCrypt(plainText []byte, key []byte) ([]byte, error) {
//1. 建立cipher.Block介面
block, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
//2. 建立分組模式，在crypto/cipher包中
iv := bytes.Repeat([]byte("1"), block.BlockSize())
stream := cipher.NewCTR(block, iv)
//3. 加密
dst := make([]byte, len(plainText))
stream.XORKeyStream(dst, plainText)
return dst, nil
}
func main() {
source:="hello world"
fmt.Println("原字元：",source)
key:="1443flfsaWfdasds"
encryptCode,_:=aesCtrCrypt([]byte(source),[]byte(key))
fmt.Println("密文：",string(encryptCode))
decryptCode,_:=aesCtrCrypt(encryptCode,[]byte(key))
fmt.Println("解密：",string(decryptCode))
}
```
##### CFB模式
```go
package main
import (
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"encoding/hex"
"fmt"
"io"
)
func AesEncryptCFB(origData []byte, key []byte) (encrypted []byte) {
block, err := aes.NewCipher(key)
if err != nil {
//panic(err)
}
encrypted = make([]byte, aes.BlockSize+len(origData))
iv := encrypted[:aes.BlockSize]
if _, err := io.ReadFull(rand.Reader, iv); err != nil {
//panic(err)
}
stream := cipher.NewCFBEncrypter(block, iv)
stream.XORKeyStream(encrypted[aes.BlockSize:], origData)
return encrypted
}
func AesDecryptCFB(encrypted []byte, key []byte) (decrypted []byte) {
block, _ := aes.NewCipher(key)
if len(encrypted) < aes.BlockSize {
panic("ciphertext too short")
}
iv := encrypted[:aes.BlockSize]
encrypted = encrypted[aes.BlockSize:]
stream := cipher.NewCFBDecrypter(block, iv)
stream.XORKeyStream(encrypted, encrypted)
return encrypted
}
func main() {
source:="hello world"
fmt.Println("原字元：",source)
key:="ABCDEFGHIJKLMNO1"//16位
encryptCode:=AesEncryptCFB([]byte(source),[]byte(key))
fmt.Println("密文：",hex.EncodeToString(encryptCode))
decryptCode:=AesDecryptCFB(encryptCode,[]byte(key))
fmt.Println("解密：",string(decryptCode))
}
```
##### OFB模式
```go
package main
import (
"bytes"
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"encoding/hex"
"fmt"
"io"
)
func aesEncryptOFB( data[]byte,key []byte) ([]byte, error) {
data = PKCS7Padding(data, aes.BlockSize)
block, _ := aes.NewCipher([]byte(key))
out := make([]byte, aes.BlockSize + len(data))
iv := out[:aes.BlockSize]
if _, err := io.ReadFull(rand.Reader, iv); err != nil {
return nil, err
}
stream := cipher.NewOFB(block, iv)
stream.XORKeyStream(out[aes.BlockSize:], data)
return out, nil
}
func aesDecryptOFB( data[]byte,key []byte) ([]byte, error) {
block, _ := aes.NewCipher([]byte(key))
iv := data[:aes.BlockSize]
data = data[aes.BlockSize:]
if len(data) % aes.BlockSize != 0 {
return nil, fmt.Errorf("data is not a multiple of the block size")
}
out := make([]byte, len(data))
mode := cipher.NewOFB(block, iv)
mode.XORKeyStream(out, data)
out= PKCS7UnPadding(out)
return out, nil
}
//補碼
//AES加密資料塊分組長度必須為128bit(byte[16])，金鑰長度可以是128bit(byte[16])、192bit(byte[24])、256bit(byte[32])中的任意一個。
func PKCS7Padding(ciphertext []byte, blocksize int) []byte {
padding := blocksize - len(ciphertext)%blocksize
padtext := bytes.Repeat([]byte{byte(padding)}, padding)
return append(ciphertext, padtext...)
}
//去碼
func PKCS7UnPadding(origData []byte) []byte {
length := len(origData)
unpadding := int(origData[length-1])
return origData[:(length - unpadding)]
}
func main() {
source:="hello world"
fmt.Println("原字元：",source)
key:="1111111111111111"//16位 32位均可
encryptCode,_:=aesEncryptOFB([]byte(source),[]byte(key))
fmt.Println("密文：",hex.EncodeToString(encryptCode))
decryptCode,_:=aesDecryptOFB(encryptCode,[]byte(key))
fmt.Println("解密：",string(decryptCode))
}
```
##### RSA加密簡介
##### rsa加密演算法簡史
>