常用加密算法go实现

最新推荐文章于 2024-05-13 09:43:40 发布
最新推荐文章于 2024-05-13 09:43:40 发布
阅读量1.4k 收藏 4
点赞数 3
文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sncot/article/details/128604731
版权

密码学

加密算法

加密算法分类：对称加密算法、非对称加密算法和杂凑算法（散列函数）

  • 对称加密算法：DES、3DES(重复三次DES过程)、AES、SM4

​ - 常用加密模式：ECB、CBC、CFB、OFB、CRT等 参考

  • 非对称加密算法：RSA、DSA、SM2、ECDSA(椭圆加密)

​ 非对称加密算法根据加密所使用的密钥不同，可分为加密(用公钥加密私钥解密)和数字签名(私钥加密公钥解密)

  • 杂凑算法：MD5、SHA-1系列、SHA-2系列、SM3

​ 杂凑算法又称为散列算法，不同算法得到定长的散列值。介绍

对称加密算法

DES

import (
	"bytes"
	"crypto/cipher"
	"crypto/des"
	"encoding/hex"
	"fmt"
)

//使用DES加密
//src 待加密明文 ， key 密钥

//加密
func EncryptDES(src, key []byte) []byte {
	//创建cipher.Block接口 其对应的就是一个加密块
	block, err := des.NewCipher(key)
	if nil != err {
		panic(err)
	}
	length := block.BlockSize()
	//填充最后一组数据
	src = PaddingText(src, length)
	//初始化向量
	iv := []byte("12345678")
	//创建cbc加密模式
	blockMode := cipher.NewCBCEncrypter(block, iv)
	//创建切片，用于存储加密后的数据
	dst := make([]byte, len(src))
	blockMode.CryptBlocks(dst, src)
	return dst
}

//解密

func DecryptDES(src, key []byte) []byte {
	//创建解密块
	block, err := des.NewCipher(key)
	if nil != err {
		panic(err)
	}
	iv := []byte("12345678")
	//创建cbc解密模式
	blockMode := cipher.NewCBCDecrypter(block, iv)
	dst := make([]byte, len(src))
	blockMode.CryptBlocks(dst, src)
	return UnPaddingText(dst)
}

func main() {
	src := []byte("你好！XXX")
	key := []byte("87654321")
	encryptedMsg := EncryptDES(src, key)
	fmt.Println("加密后:", hex.EncodeToString(encryptedMsg))
	decryptedMsg := DecryptDES(encryptedMsg, key)
	fmt.Println("解密后的明文:", string(decryptedMsg))

}

//给最后一组数据填充至64字节
func PaddingText(src []byte, blockSize int) []byte {
	//求出最后一个分组需要填充的字节数
	padding := blockSize - len(src)%blockSize
	//创建新的切片，切片字节数为padding
	padText := bytes.Repeat([]byte{byte(padding)}, padding)
	//将新创建的切片和带填充的数据进行拼接
	nextText := append(src, padText...)
	return nextText

}

//取出数据尾部填充的赘余字符

func UnPaddingText(src []byte) []byte {
	//获取待处理数据长度
	len := len(src)
	//取出最后一个字符
	num := int(src[len-1])
	newText := src[:len-num]
	return newText
}

3DES

import (
	"bytes"
	"crypto/cipher"
	"crypto/des"
	"encoding/hex"
	"fmt"
)

func Encrypt3DES(src, key []byte) []byte {
	//创建加密区块
	block, err := des.NewTripleDESCipher(key)
	if nil != err {
		panic(err)
	}
	//填充数据
	src = PaddingText(src, block.BlockSize())

	//加密
	blockmode := cipher.NewCBCEncrypter(block, key[:block.BlockSize()])
	dst := make([]byte, len(src))
	blockmode.CryptBlocks(dst, src)
	return dst
}

func Decrypt3DES(dst, key []byte) []byte {
	//创建解密块
	block, err := des.NewTripleDESCipher(key)
	if nil != err {
		panic(err)
	}
	//创建解密模式
	blockmode := cipher.NewCBCDecrypter(block, key[:block.BlockSize()])
	src := make([]byte, len(dst))
	blockmode.CryptBlocks(src, dst)
	//去除填充的数据
	src = UnPaddingText(src)
	return src
}

func main() {
	encrypt_msg := []byte("你好 XXX")
	key := []byte("123456788765432112345678")
	encrypted3DES_msg := Encrypt3DES(encrypt_msg, key)
	fmt.Println(hex.EncodeToString(encrypted3DES_msg))

	decrypt_msg := Decrypt3DES(encrypted3DES_msg, key)
	fmt.Println(string(decrypt_msg))
}

//给最后一组数据填充至64字节
func PaddingText(src []byte, blockSize int) []byte {
	//求出最后一个分组需要填充的字节数
	padding := blockSize - len(src)%blockSize
	//创建新的切片，切片字节数为padding
	padText := bytes.Repeat([]byte{byte(padding)}, padding)
	//将新创建的切片和带填充的数据进行拼接
	nextText := append(src, padText...)
	return nextText

}

//取出数据尾部填充的赘余字符

func UnPaddingText(src []byte) []byte {
	//获取待处理数据长度
	len := len(src)
	//取出最后一个字符
	num := int(src[len-1])
	newText := src[:len-num]
	return newText
}

AES

import (
	"bytes"
	"crypto/aes"
	"crypto/cipher"
	"encoding/hex"
	"fmt"
)

func EncryptAES(src, key []byte) []byte {
	block, err := aes.NewCipher(key)
	if nil != err {
		panic(err)
	}
	//填充
	src = PaddingText(src, block.BlockSize())
	//初始化向量
	iv := []byte("12345678abcdefgh")
	//创建加密模式
	blockmode := cipher.NewCBCEncrypter(block, iv)
	dst := make([]byte, len(src))
	//加密
	blockmode.CryptBlocks(dst, src)
	return dst
}

func DecryptAES(src, key []byte) []byte {
	block, err := aes.NewCipher(key)
	if nil != err {
		panic(err)
	}
	//初始化向量
	iv := []byte("12345678abcdefgh")
	blockmode := cipher.NewCBCDecrypter(block, iv)
	//解密
	dst := make([]byte, len(src))
	blockmode.CryptBlocks(dst, src)
	//去除填充
	dst = UnPaddingText(dst)
	return dst
}

func main() {
	src := []byte("你好！潘丽萍")
	key := []byte("8765432112345678")
	encryptedMsg := EncryptAES(src, key)
	fmt.Println("加密后:", hex.EncodeToString(encryptedMsg))
	decryptedMsg := DecryptAES(encryptedMsg, key)
	fmt.Println("解密后的明文:", string(decryptedMsg))
}

//给最后一组数据填充至64字节
func PaddingText(src []byte, blockSize int) []byte {
	//求出最后一个分组需要填充的字节数
	padding := blockSize - len(src)%blockSize
	//创建新的切片，切片字节数为padding
	padText := bytes.Repeat([]byte{byte(padding)}, padding)
	//将新创建的切片和带填充的数据进行拼接
	nextText := append(src, padText...)
	return nextText

}

//取出数据尾部填充的赘余字符

func UnPaddingText(src []byte) []byte {
	//获取待处理数据长度
	len := len(src)
	//取出最后一个字符
	num := int(src[len-1])
	newText := src[:len-num]
	return newText
}

SM4

import (
	"bytes"
	"crypto/cipher"
	"encoding/hex"
	"fmt"

	"github.com/tjfoc/gmsm/sm4"
)

func EncryptSM4(src, pwd []byte) []byte {
	//创建加密块
	block, err := sm4.NewCipher([]byte(pwd))
	if nil != err {
		panic(err)
	}
	//填充数据
	src = PaddingText(src, block.BlockSize())
	//初始化向量
	iv := []byte("1234567887654321")
	//设置加密模式
	blockmode := cipher.NewCBCEncrypter(block, iv)
	dst := make([]byte, len(src))
	blockmode.CryptBlocks(dst, src)
	return dst
}

func DecryptSM4(src, pwd []byte) []byte {
	//创建解密块
	block, err := sm4.NewCipher(pwd)
	if nil != err {
		panic(err)
	}
	//初始化向量
	iv := []byte("1234567887654321")
	//创建解密模式
	blockmode := cipher.NewCBCDecrypter(block, iv)
	dst := make([]byte, len(src))
	//解密
	blockmode.CryptBlocks(dst, src)

	//去除填充
	dst = UnPaddingText(dst)
	return dst
}

func main() {
	msg := []byte("你好！XXX")
	pwd := []byte("1234567887654321")
	encryptedMsg := EncryptSM4(msg, pwd)
	decryptMsg := DecryptSM4(encryptedMsg, pwd)
	fmt.Printf("%v\n%v", hex.EncodeToString(encryptedMsg), string(decryptMsg))
}

//给最后一组数据填充至64字节
func PaddingText(src []byte, blockSize int) []byte {
	//求出最后一个分组需要填充的字节数
	padding := blockSize - len(src)%blockSize
	//创建新的切片，切片字节数为padding
	padText := bytes.Repeat([]byte{byte(padding)}, padding)
	//将新创建的切片和带填充的数据进行拼接
	nextText := append(src, padText...)
	return nextText

}

//取出数据尾部填充的赘余字符

func UnPaddingText(src []byte) []byte {
	//获取待处理数据长度
	len := len(src)
	//取出最后一个字符
	num := int(src[len-1])
	newText := src[:len-num]
	return newText
}

非对称加密算法

DSA

import (
	"crypto/dsa"
	"crypto/rand"
	"fmt"
	"math/big"
)

//对消息进行加密生成数字签名
func GenDSA() (*dsa.PrivateKey, *dsa.PublicKey) {
	//生成私钥所需要的参数
	var para dsa.Parameters
	//GenerateParameters的第三个参数决定L、N的长度，长度越长加密程度越高
	dsa.GenerateParameters(&para, rand.Reader, dsa.L1024N160)
	//将初始化好的参数传入给私钥
	var priKey dsa.PrivateKey
	priKey.Parameters = para
	dsa.GenerateKey(&priKey, rand.Reader)
	return &priKey, &priKey.PublicKey
}

//验证数字签名
func EncryptDSA(priKey *dsa.PrivateKey, src []byte) (r, s *big.Int) {
	r, s, err := dsa.Sign(rand.Reader, priKey, src)
	if nil != err {
		panic(err)
	}
	return r, s
}

//验证数字签名的真实性
func VerifyDSA(pubKey *dsa.PublicKey, src []byte, r, s *big.Int) bool {
	return dsa.Verify(pubKey, src, r, s)
}

//对消息本身进行签名
func main() {
	priKey, publicKey := GenDSA()
	msg := []byte("你好！ XXX")
	r, s := EncryptDSA(priKey, msg)
	verifyDSA := VerifyDSA(publicKey, msg, r, s)
	if verifyDSA {
		fmt.Println("验证通过！")
	} else {
		fmt.Println("验证失败！")
	}
}

RSA

import (
	"crypto"
	"crypto/md5"
	"crypto/rand"
	"crypto/rsa"
	"fmt"
)

//生成密钥对
func GenKey() (*rsa.PrivateKey, *rsa.PublicKey) {
	PriKey, err := rsa.GenerateKey(rand.Reader, 2048)
	if nil != err {
		panic(err)
	}
	return PriKey, &PriKey.PublicKey
}

//用私钥和指定的hash函数对消息的散列值进行加密形成数字签名
func EncryptRSA(priKey *rsa.PrivateKey, src string) []byte {
	//对消息进行hash
	hash := md5.New()
	hash.Write([]byte(src))
	bytes := hash.Sum(nil)
	//对散列值进行加密
	opt := &rsa.PSSOptions{SaltLength: rsa.PSSSaltLengthAuto, Hash: crypto.MD5}
	sig, err := rsa.SignPSS(rand.Reader, priKey, crypto.MD5, bytes, opt)
	if nil != err {
		panic(err)
	}
	return sig
}

//验证数字签名的真实性
func VerifyRSA(pubKey *rsa.PublicKey, src string, sig []byte) bool {
	//对消息进行散列处理
	hash := md5.New()
	hash.Write([]byte(src))
	bytes := hash.Sum(nil)
	//对数字签名进行验证
	opt := &rsa.PSSOptions{SaltLength: rsa.PSSSaltLengthAuto, Hash: crypto.MD5}
	err := rsa.VerifyPSS(pubKey, crypto.MD5, bytes, sig, opt)
	if nil != err {
		fmt.Println(err)
		return false
	} else {
		return true
	}
}

//rsa对消息的散列值进行数字签名和验证
func main() {
	priKey, publicKey := GenKey()
	sig := EncryptRSA(priKey, "你好！XXX")
	verifyRSA := VerifyRSA(publicKey, "你好！XXX", sig)
	if verifyRSA {
		fmt.Println("验证通过！")
	} else {
		fmt.Println("验证失败！")
	}
}

SM2

import (
	"crypto/rand"
	"fmt"

	"github.com/tjfoc/gmsm/sm2"
)

//生成密钥对
func GenKeyPair() (*sm2.PrivateKey, *sm2.PublicKey) {
	privateKey, err := sm2.GenerateKey(rand.Reader)
	if nil != err {
		panic(err)
	}
	return privateKey, &privateKey.PublicKey
}

//对消息进行加密
func EncryptSM2(pubKey *sm2.PublicKey, src string) []byte {
	sign, err := pubKey.EncryptAsn1([]byte(src), rand.Reader)
	if nil != err {
		panic(err)
	}
	return sign
}

//对消息进行数字签名验证
func VerifySM2(priKey *sm2.PrivateKey, msg string, sign []byte) bool {
	//验证数字签名的正确性
	asn1, err := priKey.DecryptAsn1([]byte(msg))
	if nil != err {
		fmt.Println(err)
		return false
	} else {
		fmt.Println(string(asn1))
		return true
	}

}

func main() {
	msg := "你好！xxx"
	priKey, publicKey := GenKeyPair()
	sign := EncryptSM2(publicKey, msg)
	verifySM2 := VerifySM2(priKey, msg, sign)
	if verifySM2 {
		fmt.Println("验证通过")
	} else {
		fmt.Println("验证失败")
	}
}

ECDSA

import (
	"crypto/ecdsa"
	"crypto/elliptic"
	"crypto/rand"
	"crypto/sha256"
	"fmt"
	"math/big"
)

//椭圆加密算法

//生成密钥对
func GenECDSA() (*ecdsa.PrivateKey, *ecdsa.PublicKey) {
	privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
	if nil != err {
		panic(err)
	}
	return privateKey, &privateKey.PublicKey
}
func EncryptECDSA(priKey *ecdsa.PrivateKey, src string) (r, s *big.Int) {
	//对信息进行hash
	bytes := sha256.Sum256([]byte(src))
	//对散列值进行加密
	r, s, err := ecdsa.Sign(rand.Reader, priKey, bytes[:])
	if nil != err {
		panic(err)
	}
	return r, s
}

func VerifyECDSA(pubKey *ecdsa.PublicKey, src string, r, s *big.Int) bool {
	//对消息进行hash
	bytes := sha256.Sum256([]byte(src))
	//验证签名
	return ecdsa.Verify(pubKey, bytes[:], r, s)

}
func main() {
	msg := "你好！XXX"
	priKey, publicKey := GenECDSA()
	r, s := EncryptECDSA(priKey, msg)
	verifyECDSA := VerifyECDSA(publicKey, msg, r, s)
	if verifyECDSA {
		fmt.Println("验证通过")
	} else {
		fmt.Println("验证失败")
	}
}

散列算法

MD5

import (
	"crypto/md5"
	"encoding/hex"
	"fmt"
	"io"
	"os"
)

//对文件进行hash处理

func HashFileMD5(path string) string {
	//1、获取文件句柄
	file, err := os.Open(path)
	if nil != err {
		panic(err)
	}
	//2、将文件内容写入到hash
	hash := md5.New()
	_, err = io.Copy(hash, file)
	if nil != err {
		panic(err)
	}
	//3、计算散列值
	bytes := hash.Sum(nil)
	return hex.EncodeToString(bytes)
}
func main() {

	//散列对象创建
	hash := md5.New()
	//将内容写入对象
	hash.Write([]byte("区块链"))
	//计算出散列值
	sum := hash.Sum(nil)
	fmt.Println(hex.EncodeToString(sum))
	//75d8fafb0706c9381d4c91e3b184f19d

	hash.Reset()
	hash.Write([]byte("区块链"))
	bytes := hash.Sum([]byte("123"))
	fmt.Println(hex.EncodeToString(bytes))
	//313233  75d8fafb0706c9381d4c91e3b184f19d
	i := md5.Sum([]byte("区块链"))
	fmt.Println(hex.EncodeToString(i[:]))
	fileMD5 := HashFileMD5("privateKey.pem")
	fmt.Println(fileMD5, "-------3234")
}

SHA-256

import (
	"crypto/sha256"
	"encoding/hex"
	"fmt"
)

func main() {
	hash := sha256.New()
	hash.Write([]byte("你好！XXX"))
	bytes := hash.Sum(nil)
	fmt.Println(hex.EncodeToString(bytes))
	//36eda9afdaae39041fcbd101618717330a07b188373ab21f28e87e8793a7014d
}

SM3

import (
	"encoding/hex"
	"fmt"

	"github.com/tjfoc/gmsm/sm3"
)

func EncryptSM3(msg string) string {
	hash := sm3.New()
	hash.Write([]byte(msg))
	bytes := hash.Sum(nil)
	return hex.EncodeToString(bytes)
}
func main() {
	encryptSM3 := EncryptSM3("你好！XXX")
	fmt.Println(encryptSM3)
	sm3Sum := sm3.Sm3Sum([]byte("你好！XXX"))
	fmt.Println(hex.EncodeToString(sm3Sum))
}
Sncot
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
国密算法Go语言实现（详解）(三) ——SM3(杂凑算法)
weixin_46134229的博客
10-14 1093
p0() 为国标4.4条规定的置换函数。 值得称道的是，作者直接引入了GO语言标准库bits.RotateLeft32()方法，简化了代码。
国密SM3——golang的实现
weixin_42117918的博客
05-08 727
SM3密码杂凑算法是中国国家密码管理局2010年公布的中国商用密码杂凑算法标准。SM3适用于商用密码应用中的数字签名和验证，是在[]基础上改进实现的一种算法，其。
推荐开源项目：gmsm - Go语言实现的国密算法库
最新发布
gitblog_00039的博客
05-13 388
推荐开源项目：gmsm - Go语言实现的国密算法库 项目地址:https://gitcode.com/tjfoc/gmsm 1、项目介绍 gmsm是一个基于Go语言开发的全面支持中国国家标准密码算法的库，包括SM2（椭圆曲线密码算法）、SM3（哈希算法）和SM4（分组密码算法）。该项目旨在提供一套高效、稳定且易于使用的国密算法工具集，以满足开发者在构建安全系统时对国产密码技术的需求。 2、项目技...
Go实现国密算法SM2、SM3、SM4
小龙在线
07-12 2478
遵循的SM2标准号为： GM/T 0003.1-2012、GM/T 0003.2-2012、GM/T 0003.3-2012、GM/T 0003.4-2012、GM/T 0003.5-2012、GM/T 0009-2012、GM/T 0010-2012。SM3密码杂凑算法 - SM3 cryptographic hash algorithm。遵循的SM3标准号为： GM/T 0004-2012。遵循的SM4标准号为: GM/T 0002-2012。
国密SM4——golang的实现
weixin_42117918的博客
05-08 2601
SM4算法使用32轮的非线性迭代结构。SM4在最后一轮非线性迭代之后加上了一个反序变换，因此SM4中只要解密密钥是加密密钥的逆序，它的解密算法与加密算法就可以保持一致。1. CBC分组模式（Cipher Block Chaining ，密码分组链模式）以上代码中，SM4用到的库为：github.com/tjfoc/gmsm。SM4算法是我国商用密码标准，其前身是SMS4算法。整体逻辑结构如图所示，经过32轮变换把明文变换为密文。SM4算法类似于国际密码算法AES。，分组长度和密钥长度均。
保护数据隐私：深入探索Golang中的SM4加密解密算法
王中阳的博客
06-25 7778
确保网络请求数据传输的安全性、一致性和防篡改是至关重要的。通过结合对称加密和非对称加密的强大能力，我们可以实现高度安全的数据传输。对称加密提供了快速且高效的加密和解密过程，而非对称加密则保证了密钥的安全性。这种结合能够确保数据在传输过程中的保密性、完整性和可靠性，有效防止数据被篡改或窃取。无论是保护敏感信息还是确保数据的完整性，这种安全方案都是不可或缺的。
SM3 研究与实现
程序创坊
10-25 902
SM3
常用的加密算法
weixin_41659124的博客
10-28 1049
数据库自带的加密算法（直接调用函数名即可实现） 可逆的 ENCODE(str,pass_str)加密,DECODE()解密,使用 pass_str 作为密码，解密 str 。 使用 DECODE() 解密结果,效果如下： 2. 可逆的（性价比较高） AES_ENCRYPT(str ,key_str )加密 , AES_DECRYPT(crypt_str ,key_str )解密 ...
简析常见加密算法
Dongxk的博客
06-19 634
一、 概述 加密，是以某种特殊的算法改变原有的信息数据，使得未授权的用户即使获得了已加密的信息，但因不知解密的方法，仍然无法了解信息的内容。 在航空学中，指利用航空摄影像片上已知的少数控制点，通过对像片测量和计算的方法在像对或整条航摄带上增加控制点的作业。 数据加密的基本过程就是对原来为明文的文件或数据按某种算法进行处理，使其成为不可读的一段代码，通常称为“密文”，使其只能在输入相应的密钥之后才能...
Go语言实现AzDG可逆加密算法实例
09-22
在本文中，我们将深入探讨如何使用Go语言实现AzDG可逆加密算法。AzDG加密算法是一种简单的可逆加密方法，通常用于数据保护和隐私保护，它结合了MD5哈希和异或操作来达到加密的目的。以下是实现该算法的关键点： 1. ...
Golang常见加密解密算法源码.zip
09-27
"Golang常见加密解密算法源码.zip"这个压缩包显然包含了用Go语言实现的各种常见加密解密算法的源代码，这对于学习和实践信息安全技术非常有帮助。 1. **对称加密**：这是最基础的加密方式，如DES（Data Encryption ...
C++实现密码学 RSA加密解密算法
05-26
RSA加密解密算法是密码学中一种常用的加密算法，以 Ron Rivest、Adi Shamir 和 Leonard Adleman 三人命名。该算法基于大数分解问题的困难性，使用公钥加密和私钥解密的方式来保护数据的安全。 该算法的基本原理是：...
cryptutil:加密算法包装器，易于使用RSA，AES，DES等
04-06
本文将详细介绍`cryptutil`，这是一个针对Go语言设计的加密算法包装器，它使得开发者能够轻松地使用包括RSA、AES和DES在内的多种加密算法。 首先，让我们了解一下`cryptutil`的基本概念。`cryptutil`是一个开源的Go...
详解Go hash算法的支持
09-20
Go 语言中的 `crypto` 标准包提供了一些常用的哈希算法，包括 MD5（Message-Digest Algorithm 5）、SHA-1（Secure Hash Algorithm 1）、SHA-256、SHA-512 等。以下以 SHA-1 算法为例，展示如何在 Go 中生成哈希值： ...
go之sm3计算
萧海的博客
10-11 120
【代码】go之sm3计算。
国密算法Go语言实现（详解）(一) ——SM3(杂凑算法)
weixin_46134229的博客
10-14 3312
国密算法Go语言实现（详解）(一) ——SM3(杂凑算法) 出于律师的职业病，严格依据国密局公布的国家标准，对国密GO语言实现代码库进行了核实验证。在验证代码的过程中，发现了大牛ZZMarquis开发的这个GM包，逻辑清晰、充分借用了go语言标准库的既有模块，而且可以看出，基于国密推荐的加密参数结合近世代数理论，已经对算法和代码进行了相当程度的效率优化。将学习代码逻辑、核对国标验算过程的注释，连同源代码一并在此发布，希望对后来者能有些帮助。
golang连接sm3认证加密
HighGO
05-06 704
瀚高数据库 目录 环境 文档用途 详细信息 环境 系统平台：Linux x86-64 Red Hat Enterprise Linux 7 版本：4.5 文档用途 golang连接安全版sm3认证加密数据库,驱动程序详见附件。 详细信息 1.下载Linux golang安装包 go1.17.3.linux-amd64.tar.gz（详见support技术支持平台附件https://support.highgo.com/#/index/docContentHighgo/22565fef021b3e0c） 1.
用golang写个sm4
weixin_35748962的博客
12-20 516
好的，下面是用 Go 语言实现 SM4 对称加密算法的示例代码。 首先，我们需要定义一个 SM4 结构体来表示 SM4 加密算法。 type SM4 struct { key []byte } 然后，我们可以实现一个 NewSM4 函数来创建一个 SM4 结构体，并设置密钥。 funcNewSM4(key []byte) *SM4 { return &SM4{ke...
SM4 研究与实现
程序创坊
11-01 1854
SM4
golang 混淆加密
05-12
Golang 本身是一种编译型语言，可以通过编译来实现代码的保护。此外，还可以使用一些混淆和加密技术来增强代码的安全性。 一种常见的混淆技术是代码重构，即通过改变代码结构和逻辑来使代码不易被理解和分析。另一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值