Go语言实现对称加密算法AES、DES、3DES和非对称加密算法RSA

最新推荐文章于 2024-09-20 21:16:17 发布
最新推荐文章于 2024-09-20 21:16:17 发布
阅读量2.7k 收藏 28
点赞数 24
分类专栏： 遇见Golang，拥抱未来 文章标签： 加密解密 密码学 rsa aes go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45304503/article/details/118638349
版权
本文详细介绍了Go语言中对称加密算法（AES, DES, DES-CBC）的实现，包括AES-128/192/256、DES和DES的CBC模式，以及非对称加密算法（RSA）的运用，对比了对称与非对称加密的优缺点。
摘要由CSDN通过智能技术生成

目录

在这里插入图片描述

1. 对称加密算法

1.1 特点

  • 加密和解密使用的是同一个密钥，数据私密性双向保证，也就是加密和解密都不能泄露密码

1.2 优缺点

  • 优点：加密效率高，适合大些的数据加密
  • 缺点：安全性相对非对称低

1.3 go语言实现对称加密算法

1.3.1 AES

AES-128：key长度16 字节

AES-192：key长度24 字节

AES-256：key长度32 字节

var key []byte = []byte("hallenhallenhall")
// 填充密码长度
func PadPwd(srcByte []byte,blockSize int)  []byte {
	// 16 13       13-3 = 10
	padNum := blockSize - len(srcByte)%blockSize
	ret := bytes.Repeat([]byte{byte(padNum)}, padNum)
	srcByte = append(srcByte, ret...)
	return srcByte
}

// 加密
func AesEncoding(src string) (string,error) {
	srcByte := []byte(src)
	fmt.Println(srcByte)
	// safer
	block, err := aes.NewCipher(key)
	if err != nil {
		return src, err
	}
	// 密码填充
	NewSrcByte := PadPwd(srcByte, block.BlockSize())  //由于字节长度不够，所以要进行字节的填充
	fmt.Println(NewSrcByte)
	dst := make([]byte, len(NewSrcByte))
	block.Encrypt(dst, NewSrcByte)
	fmt.Println(dst)
	// base64编码
	pwd := base64.StdEncoding.EncodeToString(dst)
	return pwd, nil
}

// 去掉填充的部分
func UnPadPwd(dst []byte) ([]byte,error) {
	if len(dst) <= 0 {
		return dst, errors.New("长度有误")
	}
	// 去掉的长度
	unpadNum := int(dst[len(dst)-1])
	return dst[:(len(dst) - unpadNum)], nil
}

// 解密
func AesDecoding(pwd string) (string,error) {
	pwdByte := []byte(pwd)
	pwdByte, err := base64.StdEncoding.DecodeString(pwd)

	if err != nil {
		return pwd, err
	}
	block, errBlock := aes.NewCipher(key)
	if errBlock != nil {
		return pwd, errBlock
	}
	dst := make([]byte, len(pwdByte))
	block.Decrypt(dst, pwdByte) 	
	dst, _ = UnPadPwd(dst)		// 填充的要去掉
	return string(dst), nil
}
1.3.2 DES

DES：支持字节长度是8

// 只支持8字节的长度
var desKey = []byte("hallenha")
// 加密
func DesEncoding(src string) (string,error) {
	srcByte := []byte(src)
	block, err := des.NewCipher(desKey)
	if err != nil {
		return src, err
	}
	// 密码填充
	newSrcByte := PadPwd(srcByte, block.BlockSize())
	dst := make([]byte, len(newSrcByte))
	block.Encrypt(dst, newSrcByte)
	// base64编码
	pwd := base64.StdEncoding.EncodeToString(dst)
	return pwd, nil
}

// 解密
func DesDecoding(pwd string) (string,error) {
	pwdByte, err := base64.StdEncoding.DecodeString(pwd)
	if err != nil {
		return pwd, err
	}
	block, errBlock := des.NewCipher(desKey)
	if errBlock != nil {
		return pwd, errBlock
	}
	dst := make([]byte, len(pwdByte))
	block.Decrypt(dst, pwdByte)
	// 填充的要去掉
	dst, _ = UnPadPwd(dst)
	return string(dst), nil
}
1.3.3 DES (CBC模式)

des——CBC模式，key长度必须为24

// 3des的key，长度是24
var tdesKey = []byte("hallenhallenhallenhallen")
// 3des加密
func TDesEncoding(src string) (string,error) {
	srcByte := []byte(src)
	block, err := des.NewTripleDESCipher(tdesKey) // 和des的区别
	if err != nil {
		return src, err
	}
	// 密码填充
	newSrcByte := PadPwd(srcByte, block.BlockSize())
	dst := make([]byte, len(newSrcByte))
	block.Encrypt(dst, newSrcByte)
	// base64编码
	pwd := base64.StdEncoding.EncodeToString(dst)
	return pwd, nil
}


// 3des解密
func TDesDecoding(pwd string) (string,error) {
	pwdByte, err := base64.StdEncoding.DecodeString(pwd)
	if err != nil {
		return pwd, err
	}
	block, errBlock := des.NewTripleDESCipher(tdesKey) // 和des的区别
	if errBlock != nil {
		return pwd, errBlock
	}
	dst := make([]byte, len(pwdByte))
	block.Decrypt(dst, pwdByte)
	// 填充的要去掉
	dst, _ = UnPadPwd(dst)
	return string(dst), nil
}

2. 非对称加密算法

2.1 特点

  • 加密和解密的密钥不同，有两个密钥（公钥和私钥）

  • 公钥：可以公开的密钥；公钥加密，私钥解密

  • 私钥：私密的密钥；私钥加密，公钥解密

  • 私密单方向保证，只要有一方不泄露就没问题

2.2 优缺点

  • 优点：安全性相对对称加密高

  • 缺点：加密效率低，适合小数据加密

2.3 go语言实现非对称加密算法

消息发送方利用对方的公钥进行加密，消息接受方收到密文时使用自己的私钥进行解密

对哪一方更重要，哪一方就拿私钥

注意：

公钥和密钥生成的时候要有一种关联，要把密钥和公钥保存起来。

2.3.1 RSA
package main

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"encoding/pem"
	"fmt"
	"os"
)

// 保存生成的公钥和密钥
func SaveRsaKey(bits int) error {

	privateKey,err := rsa.GenerateKey(rand.Reader,bits)
	if err != nil {
		fmt.Println(err)
		return err
	}
	publicKey := privateKey.PublicKey

	// 使用x509标准对私钥进行编码，AsN.1编码字符串
	x509Privete := x509.MarshalPKCS1PrivateKey(privateKey)
	// 使用x509标准对公钥进行编码，AsN.1编码字符串
	x509Public := x509.MarshalPKCS1PublicKey(&publicKey)

	// 对私钥封装block 结构数据
	blockPrivate := pem.Block{Type: "private key",Bytes: x509Privete}
	// 对公钥封装block 结构数据
	blockPublic := pem.Block{Type: "public key",Bytes: x509Public}

	// 创建存放私钥的文件
	privateFile, errPri := os.Create("privateKey.pem")
	if errPri != nil {
		return errPri
	}
	defer privateFile.Close()
	pem.Encode(privateFile,&blockPrivate)

	// 创建存放公钥的文件
	publicFile, errPub := os.Create("publicKey.pem")
	if errPub != nil {
		return errPub
	}
	defer publicFile.Close()
	pem.Encode(publicFile,&blockPublic)


	return nil

}

// 加密
func RsaEncoding(src , filePath string)  ([]byte,error){

	srcByte := []byte(src)

	// 打开文件
	file,err := os.Open(filePath)
	if err != nil {
		return srcByte,err
	}

	// 获取文件信息
	fileInfo, errInfo := file.Stat()
	if errInfo != nil {
		return srcByte, errInfo
	}
	// 读取文件内容
	keyBytes := make([]byte, fileInfo.Size())
	// 读取内容到容器里面
	file.Read(keyBytes)

	// pem解码
	block,_ := pem.Decode(keyBytes)

	// x509解码
	publicKey , errPb := x509.ParsePKCS1PublicKey(block.Bytes)
	if errPb != nil {
		return srcByte, errPb
	}

	// 使用公钥对明文进行加密

	retByte, errRet := rsa.EncryptPKCS1v15(rand.Reader,publicKey, srcByte)
	if errRet != nil {
		return srcByte, errRet
	}

	return retByte,nil


}

// 解密
func RsaDecoding(srcByte []byte,filePath string) ([]byte,error) {
	// 打开文件
	file,err := os.Open(filePath)
	if err != nil {
		return srcByte,err
	}
	// 获取文件信息
	fileInfo,errInfo := file.Stat()
	if errInfo != nil {
		return srcByte,errInfo
	}
	// 读取文件内容
	keyBytes := make([]byte,fileInfo.Size())
	// 读取内容到容器里面
	_, _ = file.Read(keyBytes)
	// pem解码
	block,_ := pem.Decode(keyBytes)
	// x509解码
	privateKey ,errPb := x509.ParsePKCS1PrivateKey(block.Bytes)
	if errPb != nil {
		return keyBytes,errPb
	}
	// 进行解密
	retByte, errRet := rsa.DecryptPKCS1v15(rand.Reader,privateKey,srcByte)
	if errRet != nil {
		return srcByte,errRet
	}
	return retByte,nil
}

func main() {
	//err := SaveRsaKey(2048)
	//if err != nil {
	//	fmt.Println("KeyErr",err)
	//}
	msg, err := RsaEncoding("FanOne","publicKey.pem")
	fmt.Println("msg",msg)
	if err != nil {
		fmt.Println("err1",err)
	}
	msg2,err := RsaDecoding(msg,"privateKey.pem")
	if err != nil {
		fmt.Println("err",err)
	}
	fmt.Println("msg2",string(msg2))
}

最后

小生凡一，期待你的关注。

小生凡一
关注
专栏目录
Golang实现AES加解密——对称加密
syntax_bug609的博客
09-14 334
在上述代码中，我们首先生成了一个随机的密钥，然后使用该密钥创建一个AES块。接着，我们使用AES加密器将原始数据进行加密，并将加密后的数据转换为十六进制字符串进行展示。我们应该采取适当的措施来保证密钥的安全性，例如使用安全的随机数生成器来生成密钥，以及进行适当的密钥管理和保护。本文将介绍如何使用Golang编程语言来实现AES对称加密算法，并提供完整的源代码和相应的描述。可以使用golang.org/x/crypto包中的aes库，该库提供了对AES加密算法的支持。如果你有任何问题或疑问，请随时提出。
golang中的对称加密
后台开发
01-22 1182
概念 按位异或 第一步需要将数据转换为二进制 按位异或操作符: ^ 两个标志位进行按位异或操作: 相同为0, 不同为1 举例: 1 0 0 0 ----> 8 1 0 1 1 ----> 11 -----------------------按位异或一次 0 0 1 1 ----> 3 1 0 1 1 ----> 11 -----------------------按位异或两侧 1 0 0
Go 语言加密与解密之 AES 最佳实践
最新发布
新亮笔记
09-20 1155
上篇文章分享了 RSA 加密与解密，咱们这篇文章分享下 AES 解密与解密。AES（Advanced Encryption Standard）是目前最常用的对称加密算法之一，在数据传输和存储中提供了强大的安全保障。AES 是一种对称加密算法，这意味着加密和解密都使用同一个密钥。Go 语言提供了强大的 crypto/aes 和 crypto/cipher 包，使得 AES 加密和解密变得相对容易。一...
golang实现AES对称加密
Enzo
07-31 3202
什么是AES加密算法？   高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002...
Go-加密学(一) - 对称加密
xiangjai的专栏
06-09 662
对称加密
Go语言实现对称加密算法AES、DES、3DES和非对称加密算法RSA_golang 对称加密算法
2401_86963632的博客
09-11 739
block, errBlock := des.NewTripleDESCipher(tdesKey) // 和des的区别。block, err := des.NewTripleDESCipher(tdesKey) // 和des的区别。(img-5gTbUpXk-1726042606246)]// 3des的key，长度是24。// 保存生成的公钥和密钥。// 只支持8字节的长度。// 读取内容到容器里面。// base64编码。// base64编码。// 去掉填充的部分。
Python3非对称加密算法RSA实例详解
01-20
本文实例讲述了Python3非对称加密算法RSA。分享给大家供大家参考，具体如下： python3 可以使用 Crypto.PublicKey.RSA 和 rsa 生成公钥、私钥。 其中 python3.6 Crypto 库的安装方式请参考前面一篇《Python3对称加密...
PHP对称加密算法（DES/AES）类的实现代码
10-18
在本文中，我们将深入探讨PHP中的对称加密算法，特别是DES和AES的实现。对称加密算法使用相同的密钥进行加密和解密，这使得它们在处理大量数据时具有较高的效率，但同时也存在密钥管理和分发的挑战。 首先，我们来...
常用加密算法的Java实现总结(二)——对称加密算法DES、3DES和AES.pdf
02-10
对称加密算法包括了多种算法，本文主要介绍DES、3DES和AES这三种常见的对称加密算法，并对它们进行Java实现的总结。 首先，对称加密算法的一个关键优势在于其算法公开、计算量小、加密速度快、加密效率高，但它们也...
RSA.rar_RSA加密文件_RSA加密解密和_rsa加密算法_对称 加密文件_对称加密
09-23
对于大文件，通常先使用对称加密算法（如AES）加密，然后用RSA加密对称密钥，这样既兼顾了效率又保证了安全。 8. **其他相关概念**：除了RSA，还有其他非对称加密算法，如ECC（椭圆曲线加密）、DSA（数字签名算法）...
DES--------Golang对称加密之模式问题实战
weixin_34054866的博客
11-08 213
1. 背景 近期项目在对接第三方产品，传输过程中涉及到数据加密, 数据加密流程为： 发送数据DES加密 DES加密后的数据进行base64编码 发送，接受数据 接受读取的数据进行base64解码 base64解码完的数据机型DES解密 由于采用golang对接，文档且无说明情况下，默认采用CBC模式加解密，导致很长时间对接不上。 后通过对方Java D...
【go密码学】-对称加密算法
weixin_34265814的博客
10-11 185
对称加密 对称加密算法是相对于非对称加密算法而言，两者的区别在于，对称加密和加密和解密时使用相同的秘钥，而非对称加密在加密和解密时使用不同的秘钥（公钥和私钥）。常见的对称加密算法：DES、3DES、AES。 DES DES的基础结构，由IBM公司的Horst Feistel设计，因此称Feistel网络。在Feistel网络中，加密的每个...
Golang实现AES对称加密算法示例教程
neweastsun的专栏
02-09 4243
本文介绍Go如何实现对称加密，包括生成随机字符，Base64编码和解码，实现AES加密和解密，注意使用了内置的模块。
go语言对称加密使用（DES、3DES、AES）
咸甜适中
12-27 2083
golang对称加密、解密，DES、3DES、AES
Golang AES 对称加密
chechenshi的博客
07-22 389
需要加密手机号、身份证号和银行卡。
Go语言AES对称加密
weixin_48163046的博客
07-08 502
基于golang的字，符串对称加密功能实现
GO 对称加密算法
sunjiaoya的博客
05-06 171
GO 对称加密算法--AES对称加密算法、CFB加密模式
<golang>常用对称加密DES、3DES具体实现
weixin_42940826的博客
11-03 1899
版权声明：本文为作者原创，如需转载，请注明出处 https://blog.csdn.net/weixin_42940826 注：对称加密算法需要用分组模式的知识，在我上一篇帖子里有介绍对称加密算法常用的五种分组模式（ECB/CBC/CFB/OFB/CTR） DES简介和实现 DES – Data Encryption Standard (已经被破解不再使用，但是很有研究价值，而且诞生...
评论 22
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小生凡一

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值