Go 常用加密算法

最新推荐文章于 2024-06-20 22:23:48 发布
最新推荐文章于 2024-06-20 22:23:48 发布
阅读量199 收藏
点赞数
分类专栏： Golang # go从入门到精通 文章标签： golang 哈希算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29744347/article/details/134129663
版权

文章目录

Hash算法

md5

package main

import (
	"crypto/md5"
	"fmt"
)

func main() {
	hash := md5.New()
	hash.Write([]byte("abc"))
	fmt.Printf("hash:%x\n", hash.Sum(nil)) //hash:900150983cd24fb0d6963f7d28e17f72
}

SHA256

package main

import (
	"crypto/sha256"
	"fmt"
)

func main() {
	hash := sha256.New()
	hash.Write([]byte("abc"))
	fmt.Printf("hash:%x\n", hash.Sum(nil)) //hash:ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
}

SHA512

package main

import (
	"crypto/sha512"
	"fmt"
)

func main() {
	hash := sha512.New()
	hash.Write([]byte("abc"))
	fmt.Printf("hash:%x\n", hash.Sum(nil)) //hash:hash:ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f
}

hmac

hmac 依赖于其它hash算法，在hash算法的基础上引入了秘钥的概念，根据秘钥的不同，来生成不同的hash结果

package main

import (
	"crypto/hmac"
	"crypto/md5"
	"fmt"
)

func main() {
	example := []byte("abc")
	hash := hmac.New(md5.New, []byte("ak47"))
	hash.Write(example)
	hash2 := md5.New()
	hash2.Write(example)
	if fmt.Sprintf("%x", hash.Sum(nil)) != fmt.Sprintf("%x", hash2.Sum(nil)) {
		fmt.Println("hmac != hash") //hmac != hash
	}
}

对称加密算法

DES

要求key为8字节，加解密数据也为8字节

package main

import (
	"crypto/des"
	"fmt"
)

func main() {
	cipher, err := des.NewCipher([]byte("12345678"))
	if err != nil {
		panic(err)
	}

	EncryptResult := make([]byte, 8)
	DecryptResult := make([]byte, 8)
	plain := []byte("87654321")
	cipher.Encrypt(EncryptResult, plain)
	cipher.Decrypt(DecryptResult, EncryptResult)
	fmt.Println(plain)         //[56 55 54 53 52 51 50 49]
	fmt.Println(EncryptResult) //[56 84 48 40 155 117 148 36]
	fmt.Println(DecryptResult) //[56 55 54 53 52 51 50 49]
}

3DES

在DES的基础上，总共进行三次DES加解密，提升DES的安全性，增加暴力破解难度，由于进行三次加解密，所以需要提供24字节的key

package main

import (
	"crypto/des"
	"fmt"
)

func main() {
	cipher, err := des.NewTripleDESCipher([]byte("123456781994011319960626"))
	if err != nil {
		panic(err)
	}

	EncryptResult := make([]byte, 8)
	DecryptResult := make([]byte, 8)
	plain := []byte("87654321")
	cipher.Encrypt(EncryptResult, plain)
	cipher.Decrypt(DecryptResult, EncryptResult)
	fmt.Println(plain)         //[56 55 54 53 52 51 50 49]
	fmt.Println(EncryptResult) //[48 100 4 163 34 141 1 112]
	fmt.Println(DecryptResult) //[56 55 54 53 52 51 50 49]
}

AES

AES需要 (16,24,32)字节的key和16字节的data

package main

import (
	"crypto/aes"
	"fmt"
)

func main() {
	var (
		encryptResult = make([]byte, 16)
		key           = []byte("1234567812345678")
		source        = []byte("1111222233334444")
	)

	cipher, err := aes.NewCipher(key)
	if err != nil {
		panic(err)
	}
	cipher.Encrypt(encryptResult, source)
	fmt.Println(encryptResult) //[50 50 164 142 39 30 55 128 22 114 255 134 72 22 134 162]
}

如果加密数据超过16位，那么就要使迭代模式了,下面代码展示了使用CBC模式对32字节的数据进行加解密

package main

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

func main() {
	var (
		key           = []byte("1234567812345678")
		source        = []byte("11112222333344441111222233334444")
		encryptResult = make([]byte, 32)
		decryptResult = make([]byte, 32)
		iv            = make([]byte, 16)
	)

	cipherBlock, err := aes.NewCipher(key)
	if err != nil {
		panic(err)
	}
	encrypter := cipher.NewCBCEncrypter(cipherBlock, iv)
	encrypter.CryptBlocks(encryptResult, source)
	decrypter := cipher.NewCBCDecrypter(cipherBlock, iv)
	decrypter.CryptBlocks(decryptResult, encryptResult)
	fmt.Println(encryptResult) //[50 50 164 142 39 30 55 128 22 114 255 134 72 22 134 162]
	fmt.Println(decryptResult) //[49 49 49 49 50 50 50 50 51 51 51 51 52 52 52 52 49 49 49 49 50 50 50 50 51 51 5 1 51 52 52 52 52]
	fmt.Println(source)        //[49 49 49 49 50 50 50 50 51 51 51 51 52 52 52 52 49 49 49 49 50 50 50 50 51 51 5 1 51 52 52 52 52]
}

通常我们再迭代模式中，会将每16字节分成一个块，如果某个块不足16字节，会对其进行填充
填充方法：

package main

import (
    "bytes"
    "fmt"
)

func Pkcs5Padding(source []byte) []byte {
    padding := 16 - len(source)%16
    paddingBytes := bytes.Repeat([]byte{byte(padding)}, padding)
    return append(source, paddingBytes...)
}

func main() {
    padding := Pkcs5Padding([]byte("abc"))
    fmt.Println(padding)
}

移除填充:

package main

import (
	"bytes"
	"fmt"
)

func Pkcs5Padding(source []byte) []byte {
	padding := 16 - len(source)%16
	paddingBytes := bytes.Repeat([]byte{byte(padding)}, padding)
	return append(source, paddingBytes...)
}

func UnPkcs5Padding(source []byte) []byte {
	unPadding := int(source[len(source)-1])
	return source[:(len(source) - unPadding)]
}

func main() {
	padding := Pkcs5Padding([]byte("abc"))
	fmt.Println(padding) //[97 98 99 13 13 13 13 13 13 13 13 13 13 13 13 13]
	unPadding := UnPkcs5Padding(padding)
	fmt.Println(unPadding) //[97 98 99]
}

非对称加密

非对称加密生成两个不同的key(公钥，私钥)
公钥加密的私钥可以解，私钥加密的公钥可以解
生成私钥：

 openssl genrsa -out private.pem 2048

image.png
生成对应公钥:

openssl rsa -in private.pem -outform PEM -pubout -out public.pem

image.png

签名验签

私钥签名:

func RsaSign(plainText []byte) []byte {
	open, err := os.Open("private.pem")
	if err != nil {
		panic(err)
	}
	fileInfo, _ := open.Stat()
	data := make([]byte, fileInfo.Size())
	_, err = open.Read(data)
	if err != nil {
		panic(err)
	}
	p, _ := pem.Decode(data)
	key, err := x509.ParsePKCS1PrivateKey(p.Bytes)
	if err != nil {
		panic(err)
	}
	hashed := sha256.Sum256(plainText)
	v15, err := rsa.SignPKCS1v15(rand.Reader, key, crypto.SHA256, hashed[:])
	if err != nil {
		panic(err)
	}
	return v15
}

func main() {
	fmt.Println(RsaSign([]byte("abc")))
}

公钥验签:

package main

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

func RsaSign(plainText []byte) []byte {
	open, err := os.Open("private.pem")
	if err != nil {
		panic(err)
	}
	fileInfo, _ := open.Stat()
	data := make([]byte, fileInfo.Size())
	_, err = open.Read(data)
	if err != nil {
		panic(err)
	}
	p, _ := pem.Decode(data)
	key, err := x509.ParsePKCS1PrivateKey(p.Bytes)
	if err != nil {
		panic(err)
	}
	hashed := sha256.Sum256(plainText)
	v15, err := rsa.SignPKCS1v15(rand.Reader, key, crypto.SHA256, hashed[:])
	if err != nil {
		panic(err)
	}
	return v15
}

func VerifySign(plainText []byte, signature []byte) error {
	open, err := os.Open("public.pem")
	if err != nil {
		panic(err)
	}
	fileInfo, _ := open.Stat()
	data := make([]byte, fileInfo.Size())
	_, err = open.Read(data)
	if err != nil {
		panic(err)
	}
	p, _ := pem.Decode(data)
	key, err := x509.ParsePKIXPublicKey(p.Bytes)
	if err != nil {
		panic(err)
	}

	hashed := sha256.Sum256(plainText)

	return rsa.VerifyPKCS1v15(key.(*rsa.PublicKey), crypto.SHA256, hashed[:], signature)
}

func main() {
	signature := RsaSign([]byte("abc"))
	if err := VerifySign([]byte("abc"), signature); err != nil {
		fmt.Println("验签失败")
		return
	}
	fmt.Println("验签通过")
}

image.png

加解密

这里使用公钥加密数据，私钥解密数据
公钥加密：

package main

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

func Encrypt(plainText []byte) ([]byte, error) {
	open, err := os.Open("public.pem")
	if err != nil {
		panic(err)
	}
	fileInfo, _ := open.Stat()
	data := make([]byte, fileInfo.Size())
	_, err = open.Read(data)
	if err != nil {
		return nil, err
	}
	p, _ := pem.Decode(data)
	key, err := x509.ParsePKIXPublicKey(p.Bytes)
	if err != nil {
		return nil, err
	}
	return rsa.EncryptPKCS1v15(rand.Reader, key.(*rsa.PublicKey), plainText)
}

func main() {
	fmt.Println(Encrypt([]byte("abc")))
}

image.png
私钥解密：

package main

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

func Decrypt(plainText []byte) ([]byte, error) {
    open, err := os.Open("private.pem")
    if err != nil {
        panic(err)
    }
    fileInfo, _ := open.Stat()
    data := make([]byte, fileInfo.Size())
    _, err = open.Read(data)
    if err != nil {
        return nil, err
    }
    p, _ := pem.Decode(data)
    key, err := x509.ParsePKCS1PrivateKey(p.Bytes)
    if err != nil {
        return nil,err
    }
    return rsa.DecryptPKCS1v15(rand.Reader, key, plainText)
}

func Encrypt(plainText []byte) ([]byte, error) {
    open, err := os.Open("public.pem")
    if err != nil {
        panic(err)
    }
    fileInfo, _ := open.Stat()
    data := make([]byte, fileInfo.Size())
    _, err = open.Read(data)
    if err != nil {
        return nil, err
    }
    p, _ := pem.Decode(data)
    key, err := x509.ParsePKIXPublicKey(p.Bytes)
    if err != nil {
        return nil, err
    }
    return rsa.EncryptPKCS1v15(rand.Reader, key.(*rsa.PublicKey), plainText)
}

func main() {
    encryptData, _ := Encrypt([]byte("abc"))
    decryptData, _ := Decrypt(encryptData)
    fmt.Println(string(decryptData))
}

image.png

西直门三太子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
go区块链培训学习：密码学算法家族
qfguankefeng的博客
04-12 203
时至今日密码学已经发展了数千年，在公元前的古埃及就出现过使用特殊字符和简单替换形式的密码。近代密码的发展源自第一、二次世界大战对军事机密的保护。现代密码学的发展与计算机信息技术关系密切，已经发展为包括随机数、Hash 函数、加解密、身份认证等多个课题的庞大领域，相关成果为现代信息系统奠定了夯实的安全基础。 本文主要总结了应用密码学的一些算法。完整的安全系统不仅仅需要具备这些算法，更需要安全的系统...
Golang常用加密算法
QianLiStudent的博客
10-22 1930
Golang常用加密算法 当我们希望数据不要直接呈现出其结果时我们会选择做加密处理，比如：用户账号的密码、手机号、身份证号等敏感信息通常都是经过加密处理后再写入数据库进行存储的，否则这些信息可能会被拦截而导致信息泄露，因此这就涉及到一个加密的问题。 在密码学中常用的加密算法有3中：Hash算法、编码解码算法、加密解密算法。 ...
常用加密算法go实现
Sncot的博客
01-08 1442
常用的加密算法，对称加密、非对称加密以及摘要算法
Go语言实现对称加密算法AES、DES、3DES和非对称加密算法RSA
面向生活编程
07-10 2484
使用GO语言实现对称加密与非对称加密算法
Go语言常用加密算法
weixin_42117918的博客
09-27 6680
常见的加密算法 原文链接：https://studygolang.com/articles/10134 在项目开发过程中，当我们利用数据库存储一些关于用户的隐私信息，诸如密码、帐户密钥等数据时，需要加密后才向数据库写入。这时，我们需要一些高效地、简单易用的加密算法，当我们向数据库写数据时加密数据，然后把加密后的数据存入数据库；当需要读取数据时，从数据库把加密后的数据取出来，再通过算法解密。 ...
【Go基础】加密算法和数据结构
Ricky的博客
01-26 1963
Go作为区块链的主力语言，加密算法当然是必不可少的，本文介绍了较为常见的加密算法，略微有些潦草，会在后续的文章进一步补充区块链的内容，同时文章还介绍了四种非常常用的数据结构，其在笔试面试中考察的频率非常高
Go语言实现加密算法
xiaotai1234的博客
01-11 1040
Go语言实现加密算法 一、哈希算法 1.Hash的定义 2.流行的哈希算法 3.Hash与加密解密的区别 4.SHA256 5.核心代码 二、对称加密算法 1.概述 2.DES和TripleDES算法 3.AES加密 4.加密模式 5.填充方式 6.核心代码 三、非对称加密算法 1.发展史 2.非对称加密（Asymmetric Cryptography） 3.对称加密与非对称加密的区别 4.RSA原理 5.核心代码 四、椭圆曲线加密
Golang 常见加密解密算法
不定时分享最优质的网络技术与教程，满满的干货。
09-27 394
3DES即是设计用来提供一种相对简单的方法，即通过增加DES的密钥长度来避免类似的攻击，而不是设计一种全新的块密码算法。MD5信息摘要算法是一种被广泛使用的密码散列函数，可以产生出一个128位（16进制，32个字符）的散列值（hash value），用于确保信息传输完整一致。RSA算法是一种分组密码体制算法，它的保密强度是建立在具有大素数因子的合数其因子分解是困难的（基于大数分解的难度）。RSA得到了世界上的最广泛的应用，ISO在1992年颁布的国际标准X.509中,将RSA算法正式纳入国际标准。
GO 对称加密算法
sunjiaoya的博客
05-06 135
GO 对称加密算法--AES对称加密算法、CFB加密模式
Go语言实现AzDG可逆加密算法实例
09-22
在本文中，我们将深入探讨如何使用Go语言实现AzDG可逆加密算法。AzDG加密算法是一种简单的可逆加密方法，通常用于数据保护和隐私保护，它结合了MD5哈希和异或操作来达到加密的目的。以下是实现该算法的关键点： 1. ...
Golang常见加密解密算法源码.zip
09-27
Golang常见加密解密算法源码.zip
leetcode题库-Algorithm:算法库，主要编程语言为Python、Go、C++，包括Leetcode算法和常见加密算法等
06-29
如Leetcode算法和加密算法等。 其中Leetcode算法绝大部分为当时精挑细选的最优解 介绍 本仓库目前以文件夹作区分，主要编程语言为Python、Go、C/C++ Algorithm.py中为常用的基础算法，如二分查找，快速排序等 关于我...
详解Go hash算法的支持
09-20
Go 语言中的 `crypto` 标准包提供了一些常用的哈希算法，包括 MD5（Message-Digest Algorithm 5）、SHA-1（Secure Hash Algorithm 1）、SHA-256、SHA-512 等。以下以 SHA-1 算法为例，展示如何在 Go 中生成哈希值： ...
C++实现密码学 RSA加密解密算法
05-26
RSA加密解密算法是密码学中一种常用的加密算法，以 Ron Rivest、Adi Shamir 和 Leonard Adleman 三人命名。该算法基于大数分解问题的困难性，使用公钥加密和私钥解密的方式来保护数据的安全。 该算法的基本原理是：...
golang中的corn
shunuanwei的博客
06-20 290
golang的corn
12.3 Go 测试覆盖率
专注于全栈开发领域
06-17 837
测试覆盖率指的是测试用例覆盖代码的比例。语句覆盖（Statement Coverage）：测试用例是否执行了所有的语句。分支覆盖（Branch Coverage）：测试用例是否覆盖了所有的条件分支。函数覆盖（Function Coverage）：测试用例是否调用了所有的函数。条件覆盖（Condition Coverage）：测试用例是否覆盖了所有条件表达式的结果。测试覆盖率是衡量代码质量的重要指标之一。
【Golang - 90天从新手到大师】Day09 - string
wudawei071193的博客
06-20 924
【Golang - 90天从新手到大师】Day09 - string
go sync包（二） 互斥锁（二）
最新发布
2401_82869454的博客
06-20 450
【代码】go sync包（二） 互斥锁（二）
golang 混淆加密
05-12
另一种常见的技术是字符串加密，即使用加密算法对敏感字符串进行加密，然后在运行时解密，以避免字符串的明文出现在代码中。 在 Go 中，可以使用第三方工具来实现代码混淆和加密。其中一些工具包括： 1. Gosec：...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值