知識(shí)分享之Golang——用于在Golang中的加解密工具類三圆，包含MD5狞换、RSA超長(zhǎng)字符串、CBC舟肉、ECB等算法

背景

知識(shí)分享之Golang篇是我在日常使用Golang時(shí)學(xué)習(xí)到的各種各樣的知識(shí)的記錄修噪，將其整理出來以文章的形式分享給大家，來進(jìn)行共同學(xué)習(xí)度气。歡迎大家進(jìn)行持續(xù)關(guān)注割按。

知識(shí)分享系列目前包含Java、Golang磷籍、Linux适荣、Docker等等。

開發(fā)環(huán)境

• 系統(tǒng)：windows10
• 語(yǔ)言：Golang
• 組件庫(kù)：Bleve
• golang版本：1.18

內(nèi)容

本節(jié)我們分享一個(gè)用于在Golang中的加解密工具類院领，包含MD5弛矛、RSA超長(zhǎng)字符串、CBC比然、ECB等算法

package util

import (
    "ApiManagement/src/base/errors"
    "bytes"
    "crypto/cipher"
    "crypto/des"
    "crypto/md5"
    "crypto/rand"
    "crypto/rsa"
    "crypto/x509"
    "encoding/hex"
    "encoding/pem"
    "fmt"
    "log"
    "os"
    "strings"
)

var SysConfigDir = ""

const (
    MD5_SALT = "cnhuashao"
)

var (
    publicKey  []byte
    privateKey []byte
)

//
//  InitEncrypt
//  @Description: 初始化秘鑰
//
func InitEncrypt(pubKey, priKey string) {
    publicKey = []byte(pubKey)
    privateKey = []byte(priKey)

    //GenerateRSAKey(1024 * 4)
}

//生成RSA私鑰和公鑰丈氓，保存到文件中
func GenerateRSAKey(bits int) {
    //GenerateKey函數(shù)使用隨機(jī)數(shù)據(jù)生成器random生成一對(duì)具有指定字位數(shù)的RSA密鑰
    //Reader是一個(gè)全局、共享的密碼用強(qiáng)隨機(jī)數(shù)生成器
    privateKey, err := rsa.GenerateKey(rand.Reader, bits)
    if err != nil {
        panic(err)
    }
    //保存私鑰
    //通過x509標(biāo)準(zhǔn)將得到的ras私鑰序列化為ASN.1 的 DER編碼字符串
    X509PrivateKey := x509.MarshalPKCS1PrivateKey(privateKey)
    //使用pem格式對(duì)x509輸出的內(nèi)容進(jìn)行編碼
    //創(chuàng)建文件保存私鑰
    privateFile, err := os.Create(SysConfigDir + "private.pem")
    if err != nil {
        panic(err)
    }
    defer privateFile.Close()
    //構(gòu)建一個(gè)pem.Block結(jié)構(gòu)體對(duì)象
    privateBlock := pem.Block{Type: "RSA Private Key", Bytes: X509PrivateKey}
    //將數(shù)據(jù)保存到文件
    pem.Encode(privateFile, &privateBlock)
    //保存公鑰
    //獲取公鑰的數(shù)據(jù)
    publicKey := privateKey.PublicKey
    //X509對(duì)公鑰編碼
    X509PublicKey, err := x509.MarshalPKIXPublicKey(&publicKey)
    if err != nil {
        panic(err)
    }
    //pem格式編碼
    //創(chuàng)建用于保存公鑰的文件
    publicFile, err := os.Create(SysConfigDir + "public.pem")
    if err != nil {
        panic(err)
    }
    defer publicFile.Close()
    //創(chuàng)建一個(gè)pem.Block結(jié)構(gòu)體對(duì)象
    publicBlock := pem.Block{Type: "RSA Public Key", Bytes: X509PublicKey}
    //保存到文件
    pem.Encode(publicFile, &publicBlock)
}

func RSA_DecryptLong(cipherText []byte, paths ...string) ([]byte, error) {
    path := SysConfigDir + "private.pem"
    if len(paths) > 0 {
        path = paths[0]
    }
    //打開文件
    file, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer file.Close()
    //獲取文件內(nèi)容
    info, err := file.Stat()
    if err != nil {
        return nil, err
    }
    buf := make([]byte, info.Size())
    file.Read(buf)
    //pem解碼
    block, _ := pem.Decode(buf)
    //X509解碼
    priKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
    if err != nil {
        return nil, err
    }

    path2 := SysConfigDir + "public.pem"
    if len(paths) > 0 {
        path2 = paths[0]
    }
    //打開文件
    file2, err := os.Open(path2)
    if err != nil {
        panic(err)
    }
    defer file2.Close()
    //讀取文件的內(nèi)容
    info2, _ := file2.Stat()
    buf2 := make([]byte, info2.Size())
    file2.Read(buf2)
    //pem解碼
    block2, _ := pem.Decode(buf2)
    //x509解碼
    publicKeyInterface, err := x509.ParsePKIXPublicKey(block2.Bytes)
    if err != nil {
        panic(err)
    }
    //類型斷言
    pubKey := publicKeyInterface.(*rsa.PublicKey)

    partLen := pubKey.N.BitLen() / 8
    chunks := split(cipherText, partLen)
    buffer := bytes.NewBufferString("")
    for _, chunk := range chunks {
        //對(duì)密文進(jìn)行解密
        plainText, err := rsa.DecryptPKCS1v15(rand.Reader, priKey, chunk)
        if err != nil {
            return nil, err
        }
        buffer.Write(plainText)
    }
    //返回明文
    return []byte(buffer.String()), nil
}
func split(buf []byte, lim int) [][]byte {
    var chunk []byte
    chunks := make([][]byte, 0, len(buf)/lim+1)
    for len(buf) >= lim {
        chunk, buf = buf[:lim], buf[lim:]
        chunks = append(chunks, chunk)
    }
    if len(buf) > 0 {
        chunks = append(chunks, buf[:len(buf)])
    }
    return chunks
}

//
//  RSA_Encrypt
//  @Description: RSA加密强法，當(dāng)前端傳過來時(shí)需要使用
//  @param plainText
//  @param path
//  @return []byte
//
func RSA_Encrypt(plainText []byte, paths ...string) []byte {
    path := SysConfigDir + "public.pem"
    if len(paths) > 0 {
        path = paths[0]
    }
    //打開文件
    file, err := os.Open(path)
    if err != nil {
        panic(err)
    }
    defer file.Close()
    //讀取文件的內(nèi)容
    info, _ := file.Stat()
    buf := make([]byte, info.Size())
    file.Read(buf)
    log.Println(string(buf))
    //pem解碼
    block, _ := pem.Decode(buf)
    //x509解碼
    publicKeyInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
    if err != nil {
        panic(err)
    }
    //類型斷言
    pubKey := publicKeyInterface.(*rsa.PublicKey)
    //對(duì)明文進(jìn)行加密
    cipherText, err := rsa.EncryptPKCS1v15(rand.Reader, pubKey, plainText)
    if err != nil {
        panic(err)
    }
    //返回密文
    return cipherText
}

//
//  RSA_Decrypt
//  @Description: RSA解密
//  @param cipherText
//  @param paths
//  @return []byte
//  @return error
//
func RSA_Decrypt(cipherText []byte, paths ...string) ([]byte, error) {
    path := SysConfigDir + "private.pem"
    if len(paths) > 0 {
        path = paths[0]
    }
    //打開文件
    file, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer file.Close()
    //獲取文件內(nèi)容
    info, err := file.Stat()
    if err != nil {
        return nil, err
    }
    buf := make([]byte, info.Size())
    file.Read(buf)
    //pem解碼
    block, _ := pem.Decode(buf)
    //X509解碼
    priKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
    if err != nil {
        return nil, err
    }
    //對(duì)密文進(jìn)行解密
    plainText, err := rsa.DecryptPKCS1v15(rand.Reader, priKey, cipherText)
    if err != nil {
        return nil, err
    }
    //返回明文
    return plainText, nil
}

// Md5Crypt 加鹽MD5加密
//@params str 需要加密的字符串
//@params salt interface{} 加密的鹽
//@return str 返回md5碼
func Md5Crypt(str string, salt ...interface{}) (CryptStr string) {
    if l := len(salt); l > 0 {
        slice := make([]string, l+1)
        str = fmt.Sprintf(str+strings.Join(slice, "%v"), salt...)
    }
    return fmt.Sprintf("%x", md5.Sum([]byte(str)))
}

// MD5Bytes 數(shù)據(jù)塊MD5計(jì)算函數(shù)
func MD5Bytes(s []byte) string {
    ret := md5.Sum(s)
    return fmt.Sprintf("%x", ret)
}

// MD5 計(jì)算字符串MD5值
func MD5(s string) string {
    return MD5Bytes([]byte(s))
}

// EncryptDES_CBC CBC加密
func EncryptDES_CBC(src, key 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 //用密鑰作為向量(不建議這樣使用)
    mode := cipher.NewCBCEncrypter(block, iv)
    out := make([]byte, len(data))
    mode.CryptBlocks(out, data)
    return fmt.Sprintf("%X", out)
}

//CBC解密
func DecryptDES_CBC(src, key 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)
    }
    iv := keyByte //用密鑰作為向量(不建議這樣使用)
    mode := cipher.NewCBCDecrypter(block, iv)
    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()
    //對(duì)明文數(shù)據(jù)進(jìn)行補(bǔ)碼
    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 {
        //對(duì)明文按照blocksize進(jìn)行分塊加密
        //必要時(shí)可以使用go關(guān)鍵字進(jìn)行并行加密
        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)
}

//明文補(bǔ)碼算法
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)]
}

// RsaEncrypt Rsa加密
func RsaEncrypt(origData []byte) ([]byte, error) {
    block, _ := pem.Decode(publicKey)
    publicKeyInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
    if err != nil {
        panic(err)
    }
    //類型斷言
    pubKey := publicKeyInterface.(*rsa.PublicKey)

    encryptedBytes, err := rsa.EncryptPKCS1v15(rand.Reader, pubKey, origData)
    return encryptedBytes, err
}

// RsaDecrypt Rsa解密
func RsaDecrypt(cipherText []byte) ([]byte, error) {
    //解密
    block, _ := pem.Decode(privateKey)
    if block == nil {
        return nil, errors.New("private key error!")
    }
    //解析PKCS1格式的私鑰
    priv, err := x509.ParsePKCS1PrivateKey(block.Bytes)
    if err != nil {
        return nil, err
    }
    //解密密文
    return rsa.DecryptPKCS1v15(rand.Reader, priv, cipherText)
}

本文聲明：

88x31.png