Golang：加密解密算法(AES/DES/RSA)

缺乏、安全感 2023-10-04 22:07 22阅读 0赞

## **0.** **摘要** ##

在项目开发过程中,当操作一些用户的隐私信息,诸如密码,帐户密钥等数据时,往往需要加密后可以在网上传输.这时,需要一些高效地,简单易用的加密算法加密数据,然后把加密后的数据存入数据库或进行其他操作;当需要读取数据时,把加密后的数据取出来,再通过算法解密.

## **1.** **关于加密解密** ##

当前我们项目中常用的加解密的方式无非三种.

对称加密, 加解密都使用的是同一个密钥, 其中的代表就是AES,DES

非对加解密, 加解密使用不同的密钥, 其中的代表就是RSA

签名算法, 如MD5,SHA1,HMAC等, 主要用于验证,防止信息被修改, 如：文件校验,数字签名,鉴权协议

## **2. AES** ##

AES,即高级加密标准(Advanced Encryption Standard),是一个对称分组密码算法,旨在取代DES成为广泛使用的标准.AES中常见的有三种解决方案,分别为AES-128,AES-192和AES-256. AES加密过程涉及到4种操作：字节替代(SubBytes),行移位(ShiftRows),列混淆(MixColumns)和轮密钥加(AddRoundKey).解密过程分别为对应的逆操作.由于每一步操作都是可逆的,按照相反的顺序进行解密即可恢复明文.加解密中每轮的密钥分别由初始密钥扩展得到.算法中16字节的明文,密文和轮密钥都以一个4x4的矩阵表示. AES 有五种加密模式：电码本模式(Electronic Codebook Book (ECB)),密码分组链接模式(Cipher Block Chaining (CBC)),计算器模式(Counter (CTR)),密码反馈模式(Cipher FeedBack (CFB))和输出反馈模式(Output FeedBack (OFB))

package main
    
    import (
    	"bytes"
    	"crypto/aes"
    	"crypto/cipher"
    	"encoding/base64"
    	"fmt"
    )
    
    func main() {
    	orig := "hello world"
    	key := "123456781234567812345678"
    	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)
    
    	// 分组秘钥
    	block, err := aes.NewCipher(k)
    	if err != nil {
    		panic(fmt.Sprintf("key 长度必须 16/24/32长度: %s", err.Error()))
    	}
    	// 获取秘钥块的长度
    	blockSize := block.BlockSize()
    	// 补全码
    	origData = PKCS7Padding(origData, blockSize)
    	// 加密模式
    	blockMode := cipher.NewCBCEncrypter(block, k[:blockSize])
    	// 创建数组
    	cryted := make([]byte, len(origData))
    	// 加密
    	blockMode.CryptBlocks(cryted, origData)
    	//使用RawURLEncoding 不要使用StdEncoding
    	//不要使用StdEncoding  放在url参数中回导致错误
    	return base64.RawURLEncoding.EncodeToString(cryted)
    
    }
    
    func AesDecrypt(cryted string, key string) string {
    	//使用RawURLEncoding 不要使用StdEncoding
    	//不要使用StdEncoding  放在url参数中回导致错误
    	crytedByte, _ := base64.RawURLEncoding.DecodeString(cryted)
    	k := []byte(key)
    
    	// 分组秘钥
    	block, err := aes.NewCipher(k)
    	if err != nil {
    		panic(fmt.Sprintf("key 长度必须 16/24/32长度: %s", err.Error()))
    	}
    	// 获取秘钥块的长度
    	blockSize := block.BlockSize()
    	// 加密模式
    	blockMode := cipher.NewCBCDecrypter(block, k[:blockSize])
    	// 创建数组
    	orig := make([]byte, len(crytedByte))
    	// 解密
    	blockMode.CryptBlocks(orig, crytedByte)
    	// 去补全码
    	orig = PKCS7UnPadding(orig)
    	return string(orig)
    }
    
    // 补码
    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)]
    }

### **2.2.AES CBC** **加密** ###

package main
    
    import (
        "bytes"
        "crypto/aes"
        "crypto/cipher"
        "encoding/base64"
        "fmt"
    )
    
    const (
        key = "2018201820182018"
        iv  = "1234567887654321"
    )
    
    func main() {
        str := "我勒个去"
        es, _ := AesEncrypt(str, []byte(key))
        fmt.Println(es)
    
        ds, _ := AesDecrypt(es, []byte(key))
        fmt.Println(string(ds))
    
    }
    
    func AesEncrypt(encodeStr string, key []byte) (string, error) {
        encodeBytes := []byte(encodeStr)
        //根据key 生成密文
        block, err := aes.NewCipher(key)
        if err != nil {
            return "", err
        }
    
        blockSize := block.BlockSize()
        encodeBytes = PKCS5Padding(encodeBytes, blockSize)
    
        blockMode := cipher.NewCBCEncrypter(block, []byte(iv))
        crypted := make([]byte, len(encodeBytes))
        blockMode.CryptBlocks(crypted, encodeBytes)
    
        return base64.StdEncoding.EncodeToString(crypted), nil
    }
    
    func PKCS5Padding(ciphertext []byte, blockSize int) []byte {
        padding := blockSize - len(ciphertext)%blockSize
        //填充
        padtext := bytes.Repeat([]byte{byte(padding)}, padding)
    
        return append(ciphertext, padtext...)
    }
    
    func AesDecrypt(decodeStr string, key []byte) ([]byte, error) {
        //先解密base64
        decodeBytes, err := base64.StdEncoding.DecodeString(decodeStr)
        if err != nil {
            return nil, err
        }
        block, err := aes.NewCipher(key)
        if err != nil {
            return nil, err
        }
        blockMode := cipher.NewCBCDecrypter(block, []byte(iv))
        origData := make([]byte, len(decodeBytes))
    
        blockMode.CryptBlocks(origData, decodeBytes)
        origData = PKCS5UnPadding(origData)
        return origData, nil
    }
    
    func PKCS5UnPadding(origData []byte) []byte {
        length := len(origData)
        unpadding := int(origData[length-1])
        return origData[:(length - unpadding)]
    }

## **3. DES** ##

DES是一种对称加密算法,又称为美国数据加密标准.DES加密时以64位分组对数据进行加密,加密和解密都使用的是同一个长度为64位的密钥,实际上只用到了其中的56位,密钥中的第8,16…64位用来作奇偶校验.DES有ECB(电子密码本)和CBC(加密块)等加密模式. DES算法的安全性很高,目前除了穷举搜索破解外, 尚无更好的的办法来破解.其密钥长度越长,破解难度就越大. 填充和去填充函数.

package main
    
    import (
    	"bytes"
    	"crypto/des"
    	"encoding/hex"
    	"errors"
    	"fmt"
    	"log"
    )
    
    func main() {
    	key := []byte("2fa6c1e9")
    	str := "I love this beautiful world!"
    	strEncrypted, err := Encrypt(str, key)
    	if err != nil {
    		log.Fatal(err)
    	}
    	fmt.Println("Encrypted:", strEncrypted)
    	strDecrypted, err := Decrypt(strEncrypted, key)
    	if err != nil {
    		log.Fatal(err)
    	}
    	fmt.Println("Decrypted:", strDecrypted)
    }
    
    //Output:
    //Encrypted: 5d2333b9fbbe5892379e6bcc25ffd1f3a51b6ffe4dc7af62beb28e1270d5daa1
    //Decrypted: I love this beautiful world!
    
    func ZeroPadding(ciphertext []byte, blockSize int) []byte {
    	padding := blockSize - len(ciphertext)%blockSize
    	padtext := bytes.Repeat([]byte{0}, padding)
    	return append(ciphertext, padtext...)
    }
    
    func ZeroUnPadding(origData []byte) []byte {
    	return bytes.TrimFunc(origData,
    		func(r rune) bool {
    			return r == rune(0)
    		})
    }
    
    // 加密
    func Encrypt(text string, key []byte) (string, error) {
    	src := []byte(text)
    	block, err := des.NewCipher(key)
    	if err != nil {
    		return "", err
    	}
    	bs := block.BlockSize()
    	src = ZeroPadding(src, bs)
    	if len(src)%bs != 0 {
    		return "", errors.New("Need a multiple of the blocksize")
    	}
    	out := make([]byte, len(src))
    	dst := out
    	for len(src) > 0 {
    		block.Encrypt(dst, src[:bs])
    		src = src[bs:]
    		dst = dst[bs:]
    	}
    	return hex.EncodeToString(out), nil
    }
    
    // 解密
    func Decrypt(decrypted string, key []byte) (string, error) {
    	src, err := hex.DecodeString(decrypted)
    	if err != nil {
    		return "", err
    	}
    	block, err := des.NewCipher(key)
    	if err != nil {
    		return "", err
    	}
    	out := make([]byte, len(src))
    	dst := out
    	bs := block.BlockSize()
    	if len(src)%bs != 0 {
    		return "", errors.New("crypto/cipher: input not full blocks")
    	}
    	for len(src) > 0 {
    		block.Decrypt(dst, src[:bs])
    		src = src[bs:]
    		dst = dst[bs:]
    	}
    	out = ZeroUnPadding(out)
    	return string(out), nil
    }

## **4. RSA** ##

首先使用openssl生成公私钥,使用RSA的时候需要提供公钥和私钥 , 可以通过openss来生成对应的pem格式的公钥和私钥匙

package main
    
    import (
    	"crypto/rand"
    	"crypto/rsa"
    	"crypto/x509"
    	"encoding/base64"
    	"encoding/pem"
    	"errors"
    	"fmt"
    )
    
    // 私钥生成
    // openssl genrsa -out rsa_private_key.pem 1024
    var privateKey = []byte(`
    -----BEGIN RSA PRIVATE KEY-----
    MIICWwIBAAKBgQDcGsUIIAINHfRTdMmgGwLrjzfMNSrtgIf4EGsNaYwmC1GjF/bM
    h0Mcm10oLhNrKNYCTTQVGGIxuc5heKd1gOzb7bdTnCDPPZ7oV7p1B9Pud+6zPaco
    qDz2M24vHFWYY2FbIIJh8fHhKcfXNXOLovdVBE7Zy682X1+R1lRK8D+vmQIDAQAB
    AoGAeWAZvz1HZExca5k/hpbeqV+0+VtobMgwMs96+U53BpO/VRzl8Cu3CpNyb7HY
    64L9YQ+J5QgpPhqkgIO0dMu/0RIXsmhvr2gcxmKObcqT3JQ6S4rjHTln49I2sYTz
    7JEH4TcplKjSjHyq5MhHfA+CV2/AB2BO6G8limu7SheXuvECQQDwOpZrZDeTOOBk
    z1vercawd+J9ll/FZYttnrWYTI1sSF1sNfZ7dUXPyYPQFZ0LQ1bhZGmWBZ6a6wd9
    R+PKlmJvAkEA6o32c/WEXxW2zeh18sOO4wqUiBYq3L3hFObhcsUAY8jfykQefW8q
    yPuuL02jLIajFWd0itjvIrzWnVmoUuXydwJAXGLrvllIVkIlah+lATprkypH3Gyc
    YFnxCTNkOzIVoXMjGp6WMFylgIfLPZdSUiaPnxby1FNM7987fh7Lp/m12QJAK9iL
    2JNtwkSR3p305oOuAz0oFORn8MnB+KFMRaMT9pNHWk0vke0lB1sc7ZTKyvkEJW0o
    eQgic9DvIYzwDUcU8wJAIkKROzuzLi9AvLnLUrSdI6998lmeYO9x7pwZPukz3era
    zncjRK3pbVkv0KrKfczuJiRlZ7dUzVO0b6QJr8TRAA==
    -----END RSA PRIVATE KEY-----
    `)
    
    // 公钥: 根据私钥生成
    // openssl rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem
    var publicKey = []byte(`
    -----BEGIN PUBLIC KEY-----
    MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDcGsUIIAINHfRTdMmgGwLrjzfM
    NSrtgIf4EGsNaYwmC1GjF/bMh0Mcm10oLhNrKNYCTTQVGGIxuc5heKd1gOzb7bdT
    nCDPPZ7oV7p1B9Pud+6zPacoqDz2M24vHFWYY2FbIIJh8fHhKcfXNXOLovdVBE7Z
    y682X1+R1lRK8D+vmQIDAQAB
    -----END PUBLIC KEY-----
    `)
    
    // 加密
    func RsaEncrypt(origData []byte) ([]byte, error) {
    	//解密pem格式的公钥
    	block, _ := pem.Decode(publicKey)
    	if block == nil {
    		return nil, errors.New("public key error")
    	}
    	// 解析公钥
    	pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
    	if err != nil {
    		return nil, err
    	}
    	// 类型断言
    	pub := pubInterface.(*rsa.PublicKey)
    	//加密
    	return rsa.EncryptPKCS1v15(rand.Reader, pub, origData)
    }
    
    // 解密
    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)
    }
    func main() {
    	data, _ := RsaEncrypt([]byte("hello world"))
    	fmt.Println(base64.StdEncoding.EncodeToString(data))
    	origData, _ := RsaDecrypt(data)
    	fmt.Println(string(origData))
    }