使用Golang实现AES加解密的代码示例_Golang

前言

在现代的数据安全中，加密和解密是极其重要的一环。其中，高级加密标准（aes）是最广泛使用的加密算法之一。本文将介绍如何使用golang来实现aes加密和解密。

一、aes是什么？

高级加密标准（aes）是一种对称加密算法，也就是说，加密和解密使用相同的密钥。aes支持128、192和256位的密钥长度，越长的密钥提供了越高的安全性，但也需要更多的计算资源。aes使用固定的128位的块大小，不同的密钥长度和块大小可以组合成不同的aes变体，例如aes-128、aes-192和aes-256。

二、代码实现

以下是一个使用golang实现aes加解密的简单示例：

package main

import (
	"crypto/aes"
	"crypto/cipher"
	"encoding/base64"
	"fmt"
)

func main() {
	key := []byte("myverystrongpasswordo32bitlength") // 32 bytes key for aes-256
	plaintext := []byte("hello, world!")

	block, err := aes.newcipher(key)
	if err != nil {
		panic(err)
	}

	ciphertext := make([]byte, len(plaintext))
	stream := cipher.newctr(block, make([]byte, block.blocksize()))
	stream.xorkeystream(ciphertext, plaintext)

	fmt.printf("encrypted: %s\n", base64.stdencoding.encodetostring(ciphertext))

	decrypted := make([]byte, len(ciphertext))
	stream = cipher.newctr(block, make([]byte, block.blocksize()))
	stream.xorkeystream(decrypted, ciphertext)

	fmt.printf("decrypted: %s\n", decrypted)
}

在这个例子中，我们首先创建了一个新的cipher block。然后我们创建了一个新的ctr（counter）模式的cipher stream，并使用它来加密我们的明文。

对于解密，我们创建了一个新的ctr模式的cipher stream，并使用它来解密我们的密文。

拓展：aes加密和解密的三种模式实现

package main

import (
"bytes"
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"encoding/base64"
"encoding/hex"
"io"
"log"
)

func main() {
	origdata := []byte("杰哥的技术杂货铺") // 待加密的数据
	key := []byte("abcdefghijklmnop") // 加密的密钥
	log.println("原文：", string(origdata))

	log.println("------------------ cbc模式 --------------------")
	encrypted := aesencryptcbc(origdata, key)
	log.println("密文(hex)：", hex.encodetostring(encrypted))
	log.println("密文(base64)：", base64.stdencoding.encodetostring(encrypted))
	decrypted := aesdecryptcbc(encrypted, key)
	log.println("解密结果：", string(decrypted))

	log.println("------------------ ecb模式 --------------------")
	encrypted = aesencryptecb(origdata, key)
	log.println("密文(hex)：", hex.encodetostring(encrypted))
	log.println("密文(base64)：", base64.stdencoding.encodetostring(encrypted))
	decrypted = aesdecryptecb(encrypted, key)
	log.println("解密结果：", string(decrypted))

	log.println("------------------ cfb模式 --------------------")
	encrypted = aesencryptcfb(origdata, key)
	log.println("密文(hex)：", hex.encodetostring(encrypted))
	log.println("密文(base64)：", base64.stdencoding.encodetostring(encrypted))
	decrypted = aesdecryptcfb(encrypted, key)
	log.println("解密结果：", string(decrypted))
}

cbc/ecb/cfb 解密方法

// =================== cbc ======================
func aesencryptcbc(origdata []byte, key []byte) (encrypted []byte) {
	// 分组秘钥
	// newcipher该函数限制了输入k的长度必须为16, 24或者32
	block, _ := aes.newcipher(key)
	blocksize := block.blocksize()                              // 获取秘钥块的长度
	origdata = pkcs5padding(origdata, blocksize)                // 补全码
	blockmode := cipher.newcbcencrypter(block, key[:blocksize]) // 加密模式
	encrypted = make([]byte, len(origdata))                     // 创建数组
	blockmode.cryptblocks(encrypted, origdata)                  // 加密
	return encrypted
}
func aesdecryptcbc(encrypted []byte, key []byte) (decrypted []byte) {
	block, _ := aes.newcipher(key)                              // 分组秘钥
	blocksize := block.blocksize()                              // 获取秘钥块的长度
	blockmode := cipher.newcbcdecrypter(block, key[:blocksize]) // 加密模式
	decrypted = make([]byte, len(encrypted))                    // 创建数组
	blockmode.cryptblocks(decrypted, encrypted)                 // 解密
	decrypted = pkcs5unpadding(decrypted)                       // 去除补全码
	return decrypted
}
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)]
}

// =================== ecb ======================
func aesencryptecb(origdata []byte, key []byte) (encrypted []byte) {
	cipher, _ := aes.newcipher(generatekey(key))
	length := (len(origdata) + aes.blocksize) / aes.blocksize
	plain := make([]byte, length*aes.blocksize)
	copy(plain, origdata)
	pad := byte(len(plain) - len(origdata))
	for i := len(origdata); i < len(plain); i++ {
		plain[i] = pad
	}
	encrypted = make([]byte, len(plain))
	// 分组分块加密
	for bs, be := 0, cipher.blocksize(); bs <= len(origdata); bs, be = bs+cipher.blocksize(), be+cipher.blocksize() {
		cipher.encrypt(encrypted[bs:be], plain[bs:be])
	}

	return encrypted
}
func aesdecryptecb(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
}

// =================== cfb ======================
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
}

输出结果：

2022/08/02 20:02:24 原文：杰哥的技术杂货铺
2022/08/02 20:02:24 ------------------ cbc模式 --------------------
2022/08/02 20:02:24 密文(hex)： 6b11cae9b7831c3bbf1782a69e5504f5c32da4f6a5771e017f3a2d5ae8bf10b4
2022/08/02 20:02:24 密文(base64)： axhk6bedhdu/f4kmnlue9cmtppaldx4bfzotwui/elq=
2022/08/02 20:02:24 解密结果：杰哥的技术杂货铺
2022/08/02 20:02:24 ------------------ ecb模式 --------------------
2022/08/02 20:02:24 密文(hex)： eb69b3c7921373408f371a9f608c5915bc72d09a06994af0788542bab88387a9
2022/08/02 20:02:24 密文(base64)： 62mzx5itc0cpnxqfyixzfbxy0jogmurweivcuridh6k=
2022/08/02 20:02:24 解密结果：杰哥的技术杂货铺
2022/08/02 20:02:24 ------------------ cfb模式 --------------------
2022/08/02 20:02:24 密文(hex)： 483c4133a0ba7e0c8655d9e2a23acae4b13494a6036ab231b99bc01e7676fc0bb8c6ab7cbe6953ab
2022/08/02 20:02:24 密文(base64)： sdxbm6c6fgygvdniojrk5le0lkydarixuzvahnz2/au4xqt8vmltqw==
2022/08/02 20:02:24 解密结果：杰哥的技术杂货铺

测试用例编写解密

func testaesecbdecrypt(t *testing.t) {
	origdata := []byte("杰哥的技术杂货铺") // 待加密的数据
	key := []byte("^%tytguygsefsq7jyu5f2oij") // 加密的密钥
	log.println("原文：", string(origdata))

	log.println("------------------ cbc模式 --------------------")
	encrypted := aesencryptcbc(origdata, key)
	log.println("密文(hex)：", hex.encodetostring(encrypted))
	log.println("密文(base64)：", base64.stdencoding.encodetostring(encrypted))
	decrypted := aesdecryptcbc(encrypted, key)
	log.println("解密结果：", string(decrypted))

	log.println("------------------ ecb模式 --------------------")
	encrypted = aesencryptecb(origdata, key)
	log.println("密文(hex)：", hex.encodetostring(encrypted))
	log.println("密文(base64)：", base64.stdencoding.encodetostring(encrypted))
	decrypted = aesdecryptecb(encrypted, key)
	log.println("解密结果：", string(decrypted))

	log.println("------------------ cfb模式 --------------------")
	encrypted = aesencryptcfb(origdata, key)
	log.println("密文(hex)：", hex.encodetostring(encrypted))
	log.println("密文(base64)：", base64.stdencoding.encodetostring(encrypted))
	decrypted = aesdecryptcfb(encrypted, key)
	log.println("解密结果：", string(decrypted))
}

输出结果：

=== run testaesecbdecrypt
2022/08/03 11:23:50 原文：杰哥的技术杂货铺
2022/08/03 11:23:50 ------------------ cbc模式 --------------------
2022/08/03 11:23:50 密文(hex)： 606072d10a591454e68069ff690e63ec0cd4dcd832922aa715aaf682ff645799
2022/08/03 11:23:50 密文(base64)： ygby0qpzfftmggn/aq5j7azu3ngykiqnfar2gv9kv5k=
2022/08/03 11:23:50 解密结果：杰哥的技术杂货铺
2022/08/03 11:23:50 ------------------ ecb模式 --------------------
2022/08/03 11:23:50 密文(hex)： d31dc8357a8ab488e453b0740e91d0c241b7743b6e02f942c0a15a4417ad518a
2022/08/03 11:23:50 密文(base64)： 0x3inxqktijku7b0dphqwkg3ddtuavlcwkfarbetuyo=
2022/08/03 11:23:50 解密结果：杰哥的技术杂货铺
2022/08/03 11:23:50 ------------------ cfb模式 --------------------
2022/08/03 11:23:50 密文(hex)： e6da19018b091415326822560d16a8d614fcb0cad71bdbf3b3afe4bf3633d95e4036c5ed2a25272e
2022/08/03 11:23:50 密文(base64)： 5tozaysjfbuyacjwdrao1ht8smrxg9vzs6/kvzyz2v5ansxtkiunlg==
2022/08/03 11:23:50 解密结果：杰哥的技术杂货铺
--- pass: testaesecbdecrypt (0.04s)
pass

仅进行解密

func testaesecbdecrypt(t *testing.t) {
	key := []byte("^%tytguygsefsq7jyu5f2oij") // 加密的密钥

	log.println("------------------ cbc模式 --------------------")
	encrypted,err1 := hex.decodestring("606072d10a591454e68069ff690e63ec0cd4dcd832922aa715aaf682ff645799")
	if err1 != nil {
		t.fatal(err1)
	}
	decrypted := aesdecryptcbc(encrypted, key)
	log.println("解密结果：", string(decrypted))

	log.println("------------------ ecb模式 --------------------")
	encrypted,err2 := hex.decodestring("d31dc8357a8ab488e453b0740e91d0c241b7743b6e02f942c0a15a4417ad518a")
	if err2 != nil {
		t.fatal(err2)
	}
	decrypted = aesdecryptecb(encrypted, key)
	log.println("解密结果：", string(decrypted))

	log.println("------------------ cfb模式 --------------------")
	encrypted,err3 := hex.decodestring("ea9e17002777f1bc791d2be328c65206fff543c94b29341404926b6d0feb9a22428e6749c603352d")
	if err3 != nil {
		t.fatal(err3)
	}
	decrypted = aesdecryptcfb(encrypted, key)
	log.println("解密结果：", string(decrypted))
}

输出结果：

=== run testaesecbdecrypt
2022/08/03 11:21:27 ------------------ cbc模式 --------------------
2022/08/03 11:21:27 解密结果：杰哥的技术杂货铺
2022/08/03 11:21:27 ------------------ ecb模式 --------------------
2022/08/03 11:21:27 解密结果：杰哥的技术杂货铺
2022/08/03 11:21:27 ------------------ cfb模式 --------------------
2022/08/03 11:21:27 解密结果：杰哥的技术杂货铺
--- pass: testaesecbdecrypt (0.04s)
pass

rsa

首先使用openssl生成公私钥

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))
}