golang常见的AES、DES、RSA、MD5加密、解密、加签、验签

已于 2024-06-19 15:09:15 修改
阅读量1.8k 收藏 5
点赞数 1
文章标签： golang 开发语言 后端 安全 算法
于 2023-06-25 14:22:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39272466/article/details/131371644
版权

AES/DES/RSA 的加解密封装，PKCS5、ZERO填充方式

MD5/RSA 签名、验签
 

PKCS5 和 PKCS7 都是密码学中的填充方案，用于在加密过程中将数据填充到特定块大小的倍数。它们的区别在于块大小的不同。

  • PKCS5 填充：PKCS5 填充方案适用于使用 64 位块大小的对称加密算法（如 DES），其中填充字节的值与填充的字节数相同。例如，如果需要填充 4 字节，则填充的字节值都为 0x04。PKCS5 填充和 PKCS7 填充实际上是相同的，只是在应用 PKCS5 填充时，块大小固定为 64 位。

  • PKCS7 填充：PKCS7 填充方案适用于使用任意块大小的对称加密算法，例如 AES 的块大小可以是 128 位（16 字节），而 DES 的块大小是 64 位（8 字节）。PKCS7 填充使用填充字节的值等于填充的字节数。例如，如果需要填充 4 字节，则填充的字节值都为 0x04。

实际上，PKCS7 填充方案已经替代了 PKCS5 填充方案，并成为广泛使用的填充方式。无论是在使用 64 位块大小的加密算法还是其他块大小的加密算法，通常都使用 PKCS7 填充。因此，在大多数情况下，PKCS5 和 PKCS7 填充可以视为相同的填充方案。

package main

import (
	"bytes"
	"crypto"
	"crypto/aes"
	"crypto/cipher"
	"crypto/des"
	"crypto/md5"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"sort"
	"strings"
	// "github.com/zeromicro/go-zero/core/threading"
)

type SignAlgo struct{}

func (s *SignAlgo) SortParam(param map[string]interface{}) string {
	keys := make([]string, 0, len(param))
	for key := range param {
		keys = append(keys, key)
	}
	sort.Strings(keys)

	var sortedParams []string
	for _, key := range keys {

		value := param[key]

		if key == "sign" || value == nil || value == "" {
			continue
		}

		switch v := value.(type) {
		case int, uint, int16, int32, int64:
			sortedParams = append(sortedParams, fmt.Sprintf("%s=%d", key, v))
		case float64, float32:
			sortedParams = append(sortedParams, fmt.Sprintf("%s=%f", key, v))
		default:
			sortedParams = append(sortedParams, key+"="+value.(string))
		}

	}
	return strings.Join(sortedParams, "&")
}

func (s *SignAlgo) Sign(data map[string]interface{}, secret []byte) string {
	str := s.SortParam(data)
	str += "&key=" + string(secret)
	hash := md5.Sum(secret)
	return hex.EncodeToString(hash[:])
}

func (s *SignAlgo) Verify(data map[string]interface{}, secret []byte) bool {
	signature := data["sign"].(string)
	delete(data, "sign")
	return s.Sign(data, secret) == signature
}

// PKCS5Padding 对数据进行PKCS5填充
func PKCS5Padding(data []byte, blockSize int) []byte {
	padding := blockSize - len(data)%blockSize
	padText := bytes.Repeat([]byte{byte(padding)}, padding)
	return append(data, padText...)
}

// PKCS5Unpadding 去除PKCS5填充
func PKCS5Unpadding(data []byte) ([]byte, error) {
	length := len(data)
	if length == 0 {
		return nil, errors.New("PKCS5 unpadding error: data is empty")
	}
	unpadding := int(data[length-1])
	if unpadding > length {
		return nil, errors.New("PKCS5 unpadding error: invalid padding size")
	}
	return data[:length-unpadding], nil
}

// ZeroPadding 使用ZeroPadding填充数据
func ZeroPadding(data []byte, blockSize int) []byte {
	padding := blockSize - len(data)%blockSize
	padText := bytes.Repeat([]byte{0}, padding)
	return append(data, padText...)
}

// ZeroUnpadding 去除ZeroPadding填充数据
func ZeroUnpadding(data []byte) ([]byte, error) {
	length := len(data)
	if length == 0 {
		return nil, errors.New("ZeroUnpadding error: data is empty")
	}
	unpadding := 0
	for i := length - 1; i >= 0; i-- {
		if data[i] == 0 {
			unpadding++
		} else {
			break
		}
	}
	if unpadding == 0 {
		return nil, errors.New("ZeroUnpadding error: no padding bytes found")
	}
	return data[:length-unpadding], nil
}

func (s *SignAlgo) EnAES(data map[string]interface{}, secret []byte, iv []byte) (string, error) {
	bytes, err := json.Marshal(data)
	if err != nil {
		return "", err
	}

	// 创建AES-128加密器
	block, err := aes.NewCipher(secret)
	if err != nil {
		return "", err
	}

	// 检查IV长度是否为16字节，如果不足则进行补零操作
	if len(iv) < aes.BlockSize {
		padding := make([]byte, aes.BlockSize-len(iv))
		iv = append(iv, padding...)
	}

	// 创建CBC模式的加密器
	mode := cipher.NewCBCEncrypter(block, iv)

	// 填充原始数据
	paddedData := PKCS5Padding(bytes, aes.BlockSize)

	// 创建加密缓冲区
	encrypted := make([]byte, len(paddedData))

	// 加密数据
	mode.CryptBlocks(encrypted, paddedData)

	return base64.StdEncoding.EncodeToString(encrypted), nil
}

func (s *SignAlgo) DeAES(decrypt string, secret []byte, iv []byte) ([]byte, error) {
	decoded, err := base64.StdEncoding.DecodeString(decrypt)
	if err != nil {
		return nil, err
	}

	// 创建AES-128解密器
	block, err := aes.NewCipher(secret)
	if err != nil {
		return nil, err
	}

	// 检查IV长度是否为16字节，如果不足则进行补零操作
	if len(iv) < aes.BlockSize {
		padding := make([]byte, aes.BlockSize-len(iv))
		iv = append(iv, padding...)
	}

	// 创建CBC模式的解密器
	mode := cipher.NewCBCDecrypter(block, iv)

	// 创建解密缓冲区
	decrypted := make([]byte, len(decoded))

	// 解密数据
	mode.CryptBlocks(decrypted, decoded)

	// 去除填充数据
	unpaddedData, err := PKCS5Unpadding(decrypted)

	if err != nil {
		return nil, err
	}

	return unpaddedData, nil
}

func (s *SignAlgo) EncryptDES(data map[string]interface{}, secret []byte, iv []byte) (string, error) {
	bytes, err := json.Marshal(data)
	if err != nil {
		return "", err
	}

	// 创建DES加密器
	block, err := des.NewCipher(secret)
	if err != nil {
		return "", err
	}

	// 检查IV长度是否为8字节，如果不足则进行补零操作
	if len(iv) < des.BlockSize {
		padding := make([]byte, des.BlockSize-len(iv))
		iv = append(iv, padding...)
	}

	// 创建CBC模式的加密器
	mode := cipher.NewCBCEncrypter(block, iv)

	// 填充原始数据
	paddedData := ZeroPadding(bytes, des.BlockSize)

	// 创建加密缓冲区
	encrypted := make([]byte, len(paddedData))

	// 加密数据
	mode.CryptBlocks(encrypted, paddedData)

	return base64.StdEncoding.EncodeToString(encrypted), nil
}

func (s *SignAlgo) DecryptDES(decrypt string, secret []byte, iv []byte) ([]byte, error) {
	decoded, err := base64.StdEncoding.DecodeString(decrypt)
	if err != nil {
		return nil, err
	}

	// 创建并返回一个使用DES算法的cipher.Block接口
	block, err := des.NewCipher(secret)
	if err != nil {
		return nil, err
	}

	// 检查IV长度是否为8字节，如果不足则进行补零操作
	if len(iv) < des.BlockSize {
		padding := make([]byte, des.BlockSize-len(iv))
		iv = append(iv, padding...)
	}

	// 创建CBC模式的解密器
	mode := cipher.NewCBCDecrypter(block, iv)

	// 创建解密缓冲区
	decrypted := make([]byte, len(decoded))

	// 解密数据
	mode.CryptBlocks(decrypted, decoded)

	// 去除填充数据
	unpaddedData, err := ZeroUnpadding(decrypted)

	if err != nil {
		return nil, err
	}

	return unpaddedData, nil
}

// RSAEncrypt 使用 RSA 公钥对数据进行加密
func RSAEncrypt(data map[string]interface{}, publicKey *rsa.PublicKey) (string, error) {
	bytes, err := json.Marshal(data)
	if err != nil {
		return "", err
	}

	encryptData, err := rsa.EncryptPKCS1v15(rand.Reader, publicKey, bytes)
	if err != nil {
		return "", err
	}
	return base64.StdEncoding.EncodeToString(encryptData), nil
}

// RSADecrypt 使用 RSA 私钥对数据进行解密
func RSADecrypt(ciphertext string, privateKey *rsa.PrivateKey) ([]byte, error) {
	decoded, err := base64.StdEncoding.DecodeString(ciphertext)
	if err != nil {
		return nil, err
	}
	return rsa.DecryptPKCS1v15(rand.Reader, privateKey, decoded)
}

// RSASign 使用 RSA 私钥对数据进行签名
func RSASign(data map[string]interface{}, privateKey *rsa.PrivateKey) (string, error) {
	bytes, err := json.Marshal(data)
	if err != nil {
		return "", err
	}
	hashed := sha256.Sum256(bytes)
	sign, err := rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA256, hashed[:])
	if err != nil {
		return "", err
	}
	return base64.StdEncoding.EncodeToString(sign), nil
}

// RSAVerify 验证 RSA 签名的有效性
func RSAVerify(data map[string]interface{}, publicKey *rsa.PublicKey) error {
	signature := data["sign"].(string)
	decoded, err := base64.StdEncoding.DecodeString(signature)
	delete(data, "sign")
	bytes, err := json.Marshal(data)
	if err != nil {
		return err
	}
	hashed := sha256.Sum256(bytes)
	return rsa.VerifyPKCS1v15(publicKey, crypto.SHA256, hashed[:], decoded)
}

func main() {
	// 使用示例
	sign := &SignAlgo{}

	param := map[string]interface{}{
		"a":    1,
		"b":    "b",
		"c":    2.0,
		"d":    "d",
		"sign": "xxx",
	}

	secret := []byte("aaaaaaaabbbbbbbb")

	sortedParams := sign.SortParam(param)
	println("Sorted Params:", sortedParams)

	signature := sign.Sign(param, secret)
	println("Signature:", signature)

	param["sign"] = signature
	verified := sign.Verify(param, secret)
	println("Verified:", verified)

	encrypted, _ := sign.EnAES(param, secret, make([]byte, 0))
	println("Encrypted:", encrypted)

	decrypted, _ := sign.DeAES(encrypted, secret, make([]byte, 0))

	println("Decrypted:", string(decrypted))

	secret2 := []byte("12345678")

	desEncrypted, _ := sign.EncryptDES(param, secret2, make([]byte, 0))
	println("desEncrypted:", desEncrypted)

	desDecrypted, _ := sign.DecryptDES(desEncrypted, secret2, make([]byte, 0))

	println("desDecrypted:", string(desDecrypted))

	// threading.GoSafe()

	// 生成 RSA 密钥对
	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		fmt.Println("Failed to generate RSA private key:", err)
		return
	}
	publicKey := &privateKey.PublicKey

	// 使用公钥进行加密
	RsaEncrypted, _ := RSAEncrypt(param, publicKey)
	println("RSAencrypted:", RsaEncrypted)

	// 使用私钥进行解密
	RsaDecrypted, _ := RSADecrypt(RsaEncrypted, privateKey)
	println("RsaDecrypted:", string(RsaDecrypted))

	// 使用私钥进行签名
	RsaSignature, _ := RSASign(param, privateKey)
	println("RsaSignature:", RsaSignature)
	param["sign"] = RsaSignature

	// 验证签名的有效性
	err = RSAVerify(param, publicKey)

	fmt.Println("Signature verificatio:", err)

}

joker.zeng
关注
md5加密解密 string Md5Encode::Encode
09-28
std::(std::string src_info) { ParamDynamic param; param.ua_ = kA; param.ub_ = kB; param.uc_ = kC; param.ud_ = kD; std::string result; const char *src_data = src_info.c_str(); char *out_data_ptr = NULL; int total_byte = FillData(src_data, strlen(src_data), &out_data_ptr); char * data_BIT_OF_GROUP = out_data_ptr; for (int i = 0; i < total_byte / (BIT_OF_GROUP / BIT_OF_BYTE); ++i) { data_BIT_OF_GROUP += i*(BIT_OF_GROUP / BIT_OF_BYTE); RotationCalculate(data_BIT_OF_GROUP, param); } if (NULL != out_data_ptr) { delete[] out_data_ptr, out_data_ptr = NULL; } result.append(GetHexStr(param.ua_)); result.append(GetHexStr(param.ub_)); result.append(GetHexStr(param.uc_)); result.append(GetHexStr(param.ud_)); return result; }
GO实现MD5和RSA分段加解密
u013650708的博客
12-29 2827
前言 在尝试RSA加/解密的时候，发现go标准库中仅有&amp;amp;amp;amp;amp;amp;amp;quot;公钥加密，私钥解密&amp;amp;amp;amp;amp;amp;amp;quot;，而没有“私钥加密、公钥解密”。经过考虑，我认为GO的开发者是故意这样设计的，原因如下： 非对称加密相比对称加密的好处就是：加密方解不开密文（公钥加密后只能使用私钥才能解开） 如果仅有一对密钥，则于对称加密区别大了。 假如你是服务提供方，要求接入方进行RSA加密传输，一旦这个公钥泄漏，
Go 加密解密算法总结
无风的雨
09-23 2930
前言 加密解密在实际开发中应用比较广泛，常用加解密分为：“对称式”、“非对称式”和”数字签名“。 对称式：对称加密(也叫私钥加密)指加密和解密使用相同密钥的加密算法。具体算法主要有DES算法，3DES算法，TDEA算法，Blowfish算法，RC5算法，IDEA算法。 非对称加密(公钥加密)：指加密和解密使用不同密钥的加密算法，也称为公私钥加密。具体算法主要有RSA、Elgamal、背包算法、Rabin、D-H、ECC（椭圆曲线加密算法）。 数字签名：数字签名是非对称密钥加密技术与数字摘要技术的应用。主要算
Go使用crypto实现AES和RSA加密处理
最新发布
BOBO博客
08-25 806
通过将RSA用于密钥交换和AES用于数据加密，我们可以构建一个既安全又高效的加密系统。这种混合加密方法结合了RSA的强安全性和AES的高效性，是处理大规模数据加密的常用且有效的策略。在实际应用中，还需要注意密钥管理、加密库的选择、协议安全性以及合规性等方面的挑战。
golang实现 aes加解密,对称加密
jingzhunhuoke9的博客
11-13 500
直接上代码 package main import ( "bytes" "crypto/aes" "crypto/cipher" "encoding/base64" "fmt" "strconv" ) func PKCS7Padding(ciphertext []byte, blockSize int) []byte { padding := blockSize - len(ciphertext)%blockSize padtext :
Golang实现AES对称加密算法示例教程
neweastsun的专栏
02-09 4156
本文介绍Go如何实现对称加密，包括生成随机字符，Base64编码和解码，实现AES加密和解密，注意使用了内置的模块。
Golang AES 加解密
Dablelv 的博客专栏。
04-18 5917
利用 Go 提供的 AES 加解密与 Base64 编解码包，我们可以轻松实现 AES 加解密。实现之前，首先了解一下 AES 的基本知识。AES（Advanced Encryption Standard）高级加密标准，是流行的对称加密算法，由美国国家标准与技术研究院（NIST）于 2001 年发布，用于取代 DES。Rijndael 算法是 AES 标准的一个实现，一般说 AES 指的就是 Rijndael 算法。电子密码本模式（ECB，Electronic Code Book）；
golang 中AES加密详解
热门推荐
小虎 的博客
06-15 3万+
golang标准库中对于aes加密的阐述得非常简洁，如果没有一定的密码学基础知识，是很容易迷惑的。 本文将完整地介绍aes加密的基本知识，并分析网络上常见的调用实例。 块密码的工作模式简洁 主要摘抄自wikipedia：块密码的工作模式 基本概念 密码学中，块密码的工作模式（英语：mode of operation）允许使用同一个块密码密钥对多于一块的数据进行加密，并保证其安全性。 块密码
【Golang】使用Golang实现AES加解密
tr6666的博客
04-11 934
使用Golang实现AES加解密
Golang常见加密解密算法源码.zip
09-27
"Golang常见加密解密算法源码.zip"这个压缩包显然包含了用Go语言实现的各种常见加密解密算法的源代码，这对于学习和实践信息安全技术非常有帮助。 1. **对称加密**：这是最基础的加密方式，如DES（Data Encryption ...
文件加密解密工具（文件夹下多文件加密解密）
03-08
对称加密使用相同的密钥进行加密和解密，如DES、AES等；非对称加密则使用一对公钥和私钥，如RSA、ECC等。在本例中，由于没有具体提及使用的加密算法，我们可以假设它可能使用了常见的对称加密方式，因为这种方式在...
delphi字符串加密解密，我还有相同加密方法的php、C#、QT、golang、java版本
06-13
加密算法有多种，如对称加密（如DES, AES）和非对称加密（如RSA, ECC）。 2. **Delphi中的加密**：Delphi是一个基于Pascal语言的集成开发环境，支持各种加密库，如CryptoAPI（Windows系统内置）、BCrypt或第三方库...
QT字符串加密解密源码，我还有相同加密方法的php、C#、QT、golang、java版本
06-13
加密则是通过特定的算法（如AES、DES或RSA）将二进制数据转换为看似随机的不可读形式。解密过程则相反，它使用相同的密钥和算法将加密后的数据恢复为原始形式。 在描述中提到的加密方法可能是一种对称加密算法，...
C#字符串加密解密源码，我还有相同加密方法的delphi、php、C#、QT、golang、java版本
06-13
C#提供了System.Security.Cryptography命名空间，该命名空间包含了各种加密和解密算法，如AES（高级加密标准）、DES（数据加密标准）、RSA（公钥加密算法）等。在这个项目中，可能使用了AES或者类似的对称加密算法，...
Golang里的AES加密、解密
J_Lee
10-20 4492
Golang里的AES加密、解密
golang加密解密算法
猛犸象
03-29 2027
golang加密解密算法
Golang加密和解密应用
ManNiaoQinFen的博客
07-07 1372
Golang MD5和 Hash加密
Go实现RSA加解密
qq_37466661的博客
08-25 1744
Go实现RSA加解密
Golang RSA 生成密钥、加密、解密、签名与验签
Dablelv 的博客专栏。
09-06 2081
RSA 算法的安全性基于这个问题的难解性，目前还没有高效的方法可以在合理的时间内分解大整数。RSA 是最常用的非对称加密算法，由 Ron Rivest、Adi Shamir、Leonard Adleman 于1977 年在麻省理工学院工作时提出，RSA 是三者姓氏首字母的拼接。RSA 是一个非对称加密算法，虽然私钥也可以用于加密数据，但因为公钥是对外的，所以加密数据的意义不大，因为知道公钥的所有人都能解密。而私钥则用户签名，公钥用于验签。RSA 支持变长密钥非对称加密，需要加密的文件块的长度也是可变的。
golang实现密码登录并用md5加密
06-06
好的，我可以为您提供一个基本的示例代码，演示如何使用golang实现密码登录并用md5加密： ``` package main import ( "fmt" "crypto/md5" "encoding/hex" ) func main() { // 假设这是用户输入的密码 password := "password" // 对密码进行md5加密 hash := md5.Sum([]byte(password)) passwordHash := hex.EncodeToString(hash[:]) // 假设这是数据库中保存的用户密码hash savedPasswordHash := "5f4dcc3b5aa765d61d8327deb882cf99" // 比较用户输入的密码hash和保存的密码hash是否一致 if passwordHash == savedPasswordHash { fmt.Println("登录成功") } else { fmt.Println("密码错误") } } ``` 在这个示例中，我们首先使用md5对用户输入的密码进行加密，然后将加密后的密码与数据库中保存的密码进行比较，以进行登录验证。请注意，这只是一个基本的示例代码，实际应用中还需要考虑很多安全性和错误处理方面的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值