go语言对称加密使用（DES、3DES、AES）

最新推荐文章于 2024-09-11 16:16:59 发布
最新推荐文章于 2024-09-11 16:16:59 发布
阅读量2k 收藏 7
点赞数 3
分类专栏： golang go语言 文章标签： golang 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30712797/article/details/128451538
版权

一、数据填充

进行DES、3DES、AES三种对称加密算法时，首先要对原始数据进行字节填充，使原始数据位数与所对应加密算法块数据量成倍数。

（一）常采用PKCS5Padding填充、Zeros填充（0填充）

  • block cipher（分组密码、块密码）

  • block size（块大小）

    • DEA、3DES的block size为8位

    • AES的block size为16位

（二）PKCS5Padding

  • 每个填充的字节都记录了填充的总字节数

  • "a" 填充后：[97 7 7 7 7 7 7 7]

  • "ab" 填充后：[97 98 6 6 6 6 6 6]

  • “一a” 填充后：[228 184 128 97 4 4 4 4]

  • "12345678" 填充后：[49 50 51 52 53 54 55 56 8 8 8 8 8 8 8 8]

PKCS5Padding填充：

// 末尾填充字节
func PKCS5Padding(data []byte, blockSize int) []byte {
	padding := blockSize - len(data)%blockSize // 要填充的值和个数
	slice1 := []byte{byte(padding)}            // 要填充的单个二进制值
	slice2 := bytes.Repeat(slice1, padding)    // 要填充的二进制数组
	return append(data, slice2...)             // 填充到数据末端
}

去除PKCS5Padding填充：

// 去除填充的字节
func PKCS5UnPadding(data []byte) []byte {
	unpadding := data[len(data)-1]                // 获取二进制数组最后一个数值
	result := data[:(len(data) - int(unpadding))] // 截取开始至总长度减去填充值之间的有效数据
	return result
}

（三）ZerosPadding

  • 全部填充为0的字节

  • "a" 填充后：[97 0 0 0 0 0 0 0]

  • "ab" 填充后：[97 98 0 0 0 0 0 0]

  • “一a” 填充后：[228 184 128 97 0 0 0 0]

  • "12345678" 填充后：[49 50 51 52 53 54 55 56 0 0 0 0 0 0 0 0]

ZerosPadding填充：

// 末尾填充0
func ZerosPadding(data []byte, blockSize int) []byte {
	padding := blockSize - len(data)%blockSize // 要填充的个数
	slice1 := []byte{0}                        // 要填充的单个0数据
	slice2 := bytes.Repeat(slice1, padding)    // 要填充的0二进制数组
	return append(data, slice2...)             // 填充到数据末端
}

去除ZerosPadding填充：

// 去除填充的0
func ZerosUnPadding(data []byte) []byte {
	return bytes.TrimRightFunc(data, func(r rune) bool { // 去除满足条件的子切片
		return r == 0
	})
}

二、加密过程

// 对称加密（Symmetric Cryptography）
func SCEncrypt(originalBytes, key []byte, scType string) ([]byte, error) {
	// 1、实例化密码器block（参数为密钥）
	var err error
	var block cipher.Block
	switch scType {
	case "des":
		block, err = des.NewCipher(key)
	case "3des":
		block, err = des.NewTripleDESCipher(key)
	case "aes":
		block, err = aes.NewCipher(key)
	}
	if err != nil {
		return nil, err
	}
	blockSize := block.BlockSize()

	// 2、对明文进行填充（参数为原始字节切片和密码对象的区块个数）
	paddingBytes := PKCS5Padding(originalBytes, blockSize)

	// 3、实例化加密模式（参数为密码对象和密钥）
	blockMode := cipher.NewCBCEncrypter(block, key[:blockSize])

	// 4、对填充字节后的明文进行加密（参数为加密字节切片和填充字节切片）
	cipherBytes := make([]byte, len(paddingBytes))
	blockMode.CryptBlocks(cipherBytes, paddingBytes)
	return cipherBytes, nil
}

三、解密过程

// 对称解密
func SCDecrypt(cipherBytes, key []byte, scType string) ([]byte, error) {
	// 1、实例化密码器block（参数为密钥）
	var err error
	var block cipher.Block
	switch scType {
	case "des":
		block, err = des.NewCipher(key)
	case "3des":
		block, err = des.NewTripleDESCipher(key)
	case "aes":
		block, err = aes.NewCipher(key)
	}
	if err != nil {
		return nil, err
	}
	blockSize := block.BlockSize()

	// 2、实例化解密模式（参数为密码对象和密钥）
	blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])

	// 3、对密文进行解密（参数为填充字节切片和加密字节切片）
	paddingBytes := make([]byte, len(cipherBytes))
	blockMode.CryptBlocks(paddingBytes, cipherBytes)

	// 4、去除填充的字节（参数为填充切片）
	originalBytes := PKCS5UnPadding(paddingBytes)
	return originalBytes, nil
}

四、封装字符串加密解密

// 封装字符串对称加密
func SCEncryptString(originalText, key, scType string) (string, error) {
	cipherBytes, err := SCEncrypt([]byte(originalText), []byte(key), scType)
	if err != nil {
		return "", err
	}
	// base64 编码（encoded）
	base64str := base64.StdEncoding.EncodeToString(cipherBytes)
	return base64str, nil
}

// 封装字符串对称解密
func SCDecryptString(cipherText, key, scType string) (string, error) {
	// base64 解码（decode）
	cipherBytes, _ := base64.StdEncoding.DecodeString(cipherText)
	cipherBytes, err := SCDecrypt(cipherBytes, []byte(key), scType)
	if err != nil {
		return "", err
	}
	return string(cipherBytes), nil
}

五、完整代码

  • DES密钥占8字节

  • 3DES密钥占24字节

  • AES密钥。key长度：16，24，32 bytes 对应 AES-128，AES-192，AES-256

package main

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

func main() {
	// DES密钥
	key := "12345678" // 占8字节
	// 3DES密钥
	// key = "abcdefgh012345678" // 占24字节
	// AES密钥。key长度：16,24，32 bytes 对应 AES-128，AES-192，AES-256
	// key = "01234567abcdefgh" // 占16字节

	keyBytes := []byte(key)
	str := "a"
	cipherArr, err := SCEncrypt([]byte(str), keyBytes, "des")
	if err != nil {
		panic(err)
	}
	fmt.Printf("加密后的字节数组：%v\n", cipherArr)
	fmt.Printf("加密后的字节数组：%x\n", cipherArr)
	originalArr, _ := SCDecrypt(cipherArr, keyBytes, "des")
	fmt.Println(string(originalArr))

	fmt.Println("------------------------------------------------------")

	str = "字符串加密aa12"
	cipherText, _ := SCEncryptString(str, key, "des")
	fmt.Println(cipherText)

	originalText, _ := SCDecryptString(cipherText, key, "des")
	fmt.Println(originalText)
}

// 对称加密（Symmetric Cryptography）
func SCEncrypt(originalBytes, key []byte, scType string) ([]byte, error) {
	// 1、实例化密码器block（参数为密钥）
	var err error
	var block cipher.Block
	switch scType {
	case "des":
		block, err = des.NewCipher(key)
	case "3des":
		block, err = des.NewTripleDESCipher(key)
	case "aes":
		block, err = aes.NewCipher(key)
	}
	if err != nil {
		return nil, err
	}
	blockSize := block.BlockSize()

	// 2、对明文进行填充（参数为原始字节切片和密码对象的区块个数）
	paddingBytes := PKCS5Padding(originalBytes, blockSize)

	// 3、实例化加密模式（参数为密码对象和密钥）
	blockMode := cipher.NewCBCEncrypter(block, key[:blockSize])

	// 4、对填充字节后的明文进行加密（参数为加密字节切片和填充字节切片）
	cipherBytes := make([]byte, len(paddingBytes))
	blockMode.CryptBlocks(cipherBytes, paddingBytes)
	return cipherBytes, nil
}

// 对称解密
func SCDecrypt(cipherBytes, key []byte, scType string) ([]byte, error) {
	// 1、实例化密码器block（参数为密钥）
	var err error
	var block cipher.Block
	switch scType {
	case "des":
		block, err = des.NewCipher(key)
	case "3des":
		block, err = des.NewTripleDESCipher(key)
	case "aes":
		block, err = aes.NewCipher(key)
	}
	if err != nil {
		return nil, err
	}
	blockSize := block.BlockSize()

	// 2、实例化解密模式（参数为密码对象和密钥）
	blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])

	// 3、对密文进行解密（参数为填充字节切片和加密字节切片）
	paddingBytes := make([]byte, len(cipherBytes))
	blockMode.CryptBlocks(paddingBytes, cipherBytes)

	// 4、去除填充的字节（参数为填充切片）
	originalBytes := PKCS5UnPadding(paddingBytes)
	return originalBytes, nil
}

// 封装字符串对称加密
func SCEncryptString(originalText, key, scType string) (string, error) {
	cipherBytes, err := SCEncrypt([]byte(originalText), []byte(key), scType)
	if err != nil {
		return "", err
	}
	// base64 编码（encoded）
	base64str := base64.StdEncoding.EncodeToString(cipherBytes)
	return base64str, nil
}

// 封装字符串对称解密
func SCDecryptString(cipherText, key, scType string) (string, error) {
	// base64 解码（decode）
	cipherBytes, _ := base64.StdEncoding.DecodeString(cipherText)
	cipherBytes, err := SCDecrypt(cipherBytes, []byte(key), scType)
	if err != nil {
		return "", err
	}
	return string(cipherBytes), nil
}

// 末尾填充字节
func PKCS5Padding(data []byte, blockSize int) []byte {
	padding := blockSize - len(data)%blockSize // 要填充的值和个数
	slice1 := []byte{byte(padding)}            // 要填充的单个二进制值
	slice2 := bytes.Repeat(slice1, padding)    // 要填充的二进制数组
	return append(data, slice2...)             // 填充到数据末端
}

// 末尾填充0
func ZerosPadding(data []byte, blockSize int) []byte {
	padding := blockSize - len(data)%blockSize // 要填充的个数
	slice1 := []byte{0}                        // 要填充的单个0数据
	slice2 := bytes.Repeat(slice1, padding)    // 要填充的0二进制数组
	return append(data, slice2...)             // 填充到数据末端
}

// 去除填充的字节
func PKCS5UnPadding(data []byte) []byte {
	unpadding := data[len(data)-1]                // 获取二进制数组最后一个数值
	result := data[:(len(data) - int(unpadding))] // 截取开始至总长度减去填充值之间的有效数据
	return result
}

// 去除填充的0
func ZerosUnPadding(data []byte) []byte {
	return bytes.TrimRightFunc(data, func(r rune) bool { // 去除满足条件的子切片
		return r == 0
	})
}

咸甜适中
关注
专栏目录
Go语言实现对称加密算法AES、DES、3DES和非对称加密算法RSA
JineD的博客
03-31 750
加密和解密使用的是同一个密钥，数据私密性双向保证，也就是加密和解密都不能泄露密码。
golang实现3DES加解密
xiaoxiao_haiyan的博客
07-31 3286
3DES加解密，本文选择了CBC加解密模式。 import (     "crypto/des"     "bytes"     "crypto/cipher" ) //3DES——CBC模式，key长度必须为24，加密解密key和向量需要互相匹配 func TripleDesEncrypt(origData,key,iv []byte) ([]byte, error) {     //iv即...
Go语言实现对称加密算法AES、DES、3DES和非对称加密算法RSA_golang 对称加密算法
最新发布
2401_86963632的博客
09-11 728
block, errBlock := des.NewTripleDESCipher(tdesKey) // 和des的区别。block, err := des.NewTripleDESCipher(tdesKey) // 和des的区别。(img-5gTbUpXk-1726042606246)]// 3des的key，长度是24。// 保存生成的公钥和密钥。// 只支持8字节的长度。// 读取内容到容器里面。// base64编码。// base64编码。// 去掉填充的部分。
go语言实现对称加密
hbshhb的博客
06-23 2037
go语言实现对称加密 AES算法+CTR分组模式 加密思路 第一步：创建aes密码接口 创建一个cipher.Block接口 func NewCipher(key []byte) (cipher.Block, error) 参数：秘钥 返回值：一个分组接口 第二步：创建分组模式ctr crypto/cipher包 func NewCTR(block Block, iv []byte) St...
加密对称（一）
qq_41799182的博客
11-06 158
对称加密 1.1 基础知识点 知识点大纲介绍 密码的基础概念 对称加密 非对称加密 单向散列函数 哈希函数 消息认证码 数字签名 证书 ssl/tls - https 为什么要加密, 以及解决方案 保证数据安全 加密三要素 明文/密文 秘钥 定长的字符串 需要根据加密算法确定其长度 算法 加密算法 解密算法 加密算法和解密算法有可能是互逆的, 也有可能相同 常用的两种加密方式 对称加密 秘钥: 加密解密使用的是同一个秘钥, 秘钥有一个 特点 双方向保证机密性
Python3对称加密算法AES、DES3实例详解
01-21
本文实例讲述了Python3对称加密算法AES、DES3。分享给大家供大家参考，具体如下： python3.6此库安装方式，需要pip3 install pycryptodome。 如有site-packages中存在crypto、pycrypto，在pip之前，需要pip3 ...
详解Java利用实现对称加密（DES、3DES、AES）
08-31
本篇文章主要介绍了Java利用实现对称加密（DES、3DES、AES），具有一定的参考价值，有兴趣的可以了解一下。
python实现对称加密中3DES与AES算法工程文件
07-09
python实现对称加密中3DES与AES算法工程文件 详解博客地址：https://blog.csdn.net/m0_52316372/article/details/125691581
golang实现AES对称加密
Enzo
07-31 3201
什么是AES加密算法？   高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002...
DES--------Golang对称加密之模式问题实战
weixin_34054866的博客
11-08 213
1. 背景 近期项目在对接第三方产品，传输过程中涉及到数据加密, 数据加密流程为： 发送数据DES加密 DES加密后的数据进行base64编码 发送，接受数据 接受读取的数据进行base64解码 base64解码完的数据机型DES解密 由于采用golang对接，文档且无说明情况下，默认采用CBC模式加解密，导致很长时间对接不上。 后通过对方Java D...
Go-加密学(一) - 对称加密
xiangjai的专栏
06-09 661
对称加密
golang中的对称加密
后台开发
01-22 1178
概念 按位异或 第一步需要将数据转换为二进制 按位异或操作符: ^ 两个标志位进行按位异或操作: 相同为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
golang 3DES 加密
fareast_mzh的博客
03-27 1816
key, iv 自己随意设定 为了让结果可正常打印输入显示，都经过base64处理 * TripleDES.go package auth import ( "bytes" "crypto/cipher" "crypto/des" "encoding/base64" ) type TripleDES struct { key string iv string } ...
Golang AES 对称加密
chechenshi的博客
07-22 388
需要加密手机号、身份证号和银行卡。
使用GO语言实现对称加密，DES、3DES、AES
July_whj
08-31 998
使用GO语言实现对称加密，DES、3DES、AES测试程序 package main import ( "bytes" "crypto/aes" "crypto/cipher" "crypto/des" ) // 填充最后一个分组的函数 // src - 原始数据 // blockSize - 每个分组的数据长度 func padding(src []byte, blockSize i...
Go语言AES对称加密
weixin_48163046的博客
07-08 502
基于golang的字，符串对称加密功能实现
Go语言实现DES加密算法（一）—— DES算法概念、DES的CBC模式、Go语言实例实现
The_Reader的博客
09-06 1589
DES算法 DES内部实现理论： 在des中的各个步骤称之为轮，整个加密过程需要进行16轮循环。   子密钥：中间的子密钥指的是本轮加密使用的密钥，每一轮都需要使用一个不同的子密钥，由于它只在一轮中使用，只是一个局部密钥，所以称之为子密钥。 轮函数:根据右侧和子密钥生成对左侧进行加密的比特序列，它是密码体系的核心。 右半侧实际上没有进行任何处理，者在加密算法中看起来比较浪费...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值