脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 脚本专栏 → Golang → Golang实现AES对称加密算法

Golang实现AES对称加密算法实例详解

 更新时间：2023年02月21日 09:50:04   作者：梦想画家  
所谓对称加密是指在加密和解码时使用同一密钥的加密方式,下面这篇文章主要给大家介绍了关于Golang实现AES对称加密算法的相关资料,文中通过实例代码介绍的非常详细,需要的朋友可以参考下

前言

安全总是相对的，对于敏感数据最好要有一定保护措施，尤其是在线数据，通过加密可转换信息为编码，从而防止非法获取。对开发者来说，加密本质是保护应用程序数据，假设我们以明文存储用户密码，可能会导致信息泄露。使用密文在一定程度上可避免信息落入他人之手，本文介绍Golang的对称加密算法实现。

前置知识

在正式学习加密解密之前，首先看看如何生成随机数，以及为什么要随机数。

生成随机数

编程中生成随机数或字符串非常重要，它是加密的基础工作。如果没有随机生成数，加密可能会失去作用，让加密数据可预测。为了生成随机数，Go提供了math/rand包及其他工具，下面通过实例说明：

package main
import (
    "fmt"
    "math/rand"
)
func main() {
    fmt.Println(rand.Intn(100))
}

程序很简单，生成[0,100)之间的整数，但多次运行程序，会发现每次结果都一样。这是因为程序按照算法设定，默认随机种子为1，因此每次结果相同。我们通过设置不同随机种子修复错误：

package main
import (
    "fmt"
    "math/rand"
     "time"
)
func main() {
    rand.Seed(time.Now().UnixNano())
    fmt.Println(rand.Intn(100))
}

这样每次运行时随机种子不同，结果自然就不同。

生成随机字符串

为了在Go中生成随机字符串，我们使用Base64编码和外部包，这是一种更实用和安全的方式。

首先我们看Base64编码：

package main

import (
    "encoding/base64"
    "fmt"
)

func main() {

    StringToEncode := "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

    Encoding := base64.StdEncoding.EncodeToString([]byte(StringToEncode))
    fmt.Println(Encoding)                                        
}

通过使用Base64编码，可以对字符串进行编码或解码，上面示例对StringToEncode字符值进行base64编码，读者可以运行程序查看结果。
为了每次运行返回结果不同，可以使用第三方包randstr,它采用比使用Seed方法更好更快的方法，安装命令为：

go get -u github.com/thanhpk/randstr

下面示例生成随机长度为20字符串，代码如下：

package main
import(
  "github.com/thanhpk/randstr"
  "fmt"
)

func main() {
    MyString := randstr.String(20)
    fmt.Println(MyString)
}

运行多次，每次结果都不同。

加密和解密

了解了生成随机字符和数字，下面进入正题，加密和解密。要了解安全，需要先了解这些模块：crypto/aes, crypto/cipher, encoding/base64。

加密

加密是隐藏数据的方法，是的别有用心的人拿到数据也没有用。这里主要使用crypto/aes(Advanced Encryption Standard)包提供的功能。

package main

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

var bytes = []byte{35, 46, 57, 24, 85, 35, 24, 74, 87, 35, 88, 98, 66, 32, 14, 05}

// 生成环境应该通过配置文件获取
const MySecret string = "abc&1*~#^2^#s0^=)^^7%b34"

func Encode(b []byte) string {
    return base64.StdEncoding.EncodeToString(b)
}


// 加密方法可以加密任何类型文本
func Encrypt(text, MySecret string) (string, error) {
    block, err := aes.NewCipher([]byte(MySecret))
    if err != nil {
        return "", err
    }

    plainText := []byte(text)
    cfb := cipher.NewCFBEncrypter(block, bytes)
    cipherText := make([]byte, len(plainText))
    cfb.XORKeyStream(cipherText, plainText)

    return Encode(cipherText), nil
}

func main() {
    StringToEncrypt := "Encrypting this string"

    // To encrypt the StringToEncrypt
    encText, err := Encrypt(StringToEncrypt, MySecret)
    if err != nil {
     fmt.Println("error encrypting your classified text: ", err)
    }
    fmt.Println(encText)
}

crypto/cipher包中NewCFBEncrypter方法使用16字节随机值作为参数，注意这里长度必须为16，因为AES默认block长度为16，这两者长度要一致，不同长度对应不同算法，对应关系如下：

16, 24, or 32， AES-128, AES-192, or AES-256.

cipher.go的源码定义如下：

// The AES block size in bytes.
const BlockSize = 16

// A cipher is an instance of AES encryption using a particular key.
type aesCipher struct {
	enc []uint32
	dec []uint32
}

type KeySizeError int

func (k KeySizeError) Error() string {
	return "crypto/aes: invalid key size " + strconv.Itoa(int(k))
}

// NewCipher creates and returns a new cipher.Block.
// The key argument should be the AES key,
// either 16, 24, or 32 bytes to select
// AES-128, AES-192, or AES-256.
...

再看下NewCFBEncrypter方法源码，注释写的很清楚两者长度需相同。

// NewCFBEncrypter returns a Stream which encrypts with cipher feedback mode,
// using the given Block. The iv must be the same length as the Block's block
// size.
func NewCFBEncrypter(block Block, iv []byte) Stream {
	return newCFB(block, iv, false)
}

Encrypt函数带两个参数，待加密的明文和加密的密钥。MySecret常量是加密方法所需的密钥，最后通过Encode函数返回Base64格式的密文。运行程序，输出结果即为密文，是StringToEncrypt变量值加密的结果。

Li5E8RFcV/EPZY/neyCXQYjrfa/atA==

解密

成功加密字符串后，需要能够正确解密，从密文还原为明文。典型的场景是用户数据是加密后存入数据库中，当用户再次访问时需要能够正确解密。也就说我们需要把前节中加密的密文正确还原为明文，首先需要使用解码函数，该函数会在解密方法中使用：

func Decode(s string) []byte {
    data, err := base64.StdEncoding.DecodeString(s)
    if err != nil {
        panic(err)
    }
    return data
}

Decode函数有一个参数，对于Base64编码进行解码，解密方法代码如下：

// 解密方法把密文正确转为明文
func Decrypt(text, MySecret string) (string, error) {
    block, err := aes.NewCipher([]byte(MySecret))

    if err != nil {
        return "", err
    }
    cipherText := Decode(text)

    cfb := cipher.NewCFBDecrypter(block, bytes)
    plainText := make([]byte, len(cipherText))
    cfb.XORKeyStream(plainText, cipherText)

    return string(plainText), nil
}

解密方法包括两个参数：text是密文，MySeret是密钥。在main函数中可以对前面密文进行解密并输出明文：

decText, err := Decrypt("Li5E8RFcV/EPZY/neyCXQYjrfa/atA==", MySecret)
if err != nil {
    fmt.Println("error decrypting your encrypted text: ", err)
}

fmt.Println(decText)

最后给出完整代码和注释：

package main

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

// 16位随机字符串
var bytes = []byte{35, 46, 57, 24, 85, 35, 24, 74, 87, 35, 88, 98, 66, 32, 14, 05}

// 密钥，实际应用中应该从环境变量或文件中获取
const MySecret string = "abc&1*~#^2^#s0^=)^^7%b34"

// Base64编码和解码方法
func Encode(b []byte) string {
	return base64.StdEncoding.EncodeToString(b)
}

func Decode(s string) []byte {
	data, err := base64.StdEncoding.DecodeString(s)
	if err != nil {
		panic(err)
	}
	return data
}

// 加密方法
func Encrypt(text, MySecret string) (string, error) {
	block, err := aes.NewCipher([]byte(MySecret))
	if err != nil {
		return "", err
	}

	plainText := []byte(text)
	cfb := cipher.NewCFBEncrypter(block, bytes)
	cipherText := make([]byte, len(plainText))
	cfb.XORKeyStream(cipherText, plainText)

	return Encode(cipherText), nil
}

// 解密方法
func Decrypt(text, MySecret string) (string, error) {
	block, err := aes.NewCipher([]byte(MySecret))
	if err != nil {
		return "", err
	}

	cipherText := Decode(text)
	cfb := cipher.NewCFBDecrypter(block, bytes)
	plainText := make([]byte, len(cipherText))
	cfb.XORKeyStream(plainText, cipherText)

	return string(plainText), nil
}

func main() {
	StringToEncrypt := "Encrypting this string"

	// 对StringToEncrypt变量值进行加密
	encText, err := Encrypt(StringToEncrypt, MySecret)
	if err != nil {
		fmt.Println("error encrypting your classified text: ", err)
	}
	fmt.Println(encText)

	// 对密文进行解密
	decText, err := Decrypt("Li5E8RFcV/EPZY/neyCXQYjrfa/atA==", MySecret)
	if err != nil {
		fmt.Println("error decrypting your encrypted text: ", err)
	}
	
	fmt.Println(decText)
}

结合前面的内容，当然可以每次动态获取16位随机数，加密完成后和密文连接一起返回：cipherText = append(cipherText, bytes...),最后解密时从密文中先截取随机数再解密，从而让每次加密生成的密文都不一样。

总结

本文介绍Go如何实现对称加密，包括生成随机字符，Base64编码和解码，实现AES加密和解密，注意使用了内置的crypto/aes, crypto/cipher, encoding/base64模块。

到此这篇关于Golang实现AES对称加密算法的文章就介绍到这了,更多相关Golang实现AES对称加密算法内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • Go语言 go程释放操作(退出/销毁)

    Go语言 go程释放操作(退出/销毁)

    这篇文章主要介绍了Go语言 go程释放操作(退出/销毁)，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2021-04-04
  • Go结合反射将结构体转换成Excel的过程详解

    Go结合反射将结构体转换成Excel的过程详解

    这篇文章主要介绍了Go结合反射将结构体转换成Excel的过程详解,大概思路是在Go的结构体中每个属性打上一个excel标签，利用反射获取标签中的内容，作为表格的Header，需要的朋友可以参考下
    2022-06-06
  • Golang中禁止拷贝的实现代码

    Golang中禁止拷贝的实现代码

    这篇文章主要给大家介绍了关于Golang中实现禁止拷贝的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2018-11-11
  • go Http Post 发送文件流案例

    go Http Post 发送文件流案例

    这篇文章主要介绍了go Http Post 发送文件流案例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2020-12-12
  • Go语言eclipse环境搭建图文教程

    Go语言eclipse环境搭建图文教程

    这篇文章主要介绍了Go语言eclipse环境搭建的方法,结合图文形式详细分析了在eclipse环境下开发Go语言所涉及的组件下载、安装及相关设置方法,需要的朋友可以参考下
    2016-07-07
  • Go语言中的复合类型详细介绍

    Go语言中的复合类型详细介绍

    这篇文章主要介绍了Go语言中的复合类型详细介绍,复合类型包括：结构体、数组、切片、Maps,需要的朋友可以参考下
    2014-10-10
  • Golang的关键字defer的使用方法

    Golang的关键字defer的使用方法

    这篇文章主要介绍了Golang的关键字defer的使用方法，文章围绕主题展开详细的内容介绍，具有一定的参考价值，需要的小伙伴可以参考一下
    2022-06-06
  • go语言异常panic和恢复recover用法实例

    go语言异常panic和恢复recover用法实例

    这篇文章主要介绍了go语言异常panic和恢复recover用法,实例分析了异常panic和恢复recover使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
    2015-03-03
  • Golang中的包及包管理工具go mod详解

    Golang中的包及包管理工具go mod详解

    这篇文章主要介绍了Golang中的包及包管理工具go mod，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2022-07-07
  • k8s容器互联-flannel host-gw原理篇

    k8s容器互联-flannel host-gw原理篇

    这篇文章主要为大家介绍了k8s容器互联-flannel host-gw原理篇，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2023-04-04

最新评论