1. Toy模板网首页
  2. > Toy博客

Go 常用加密算法

10月前 作者：西直门三太子 分类：Toy博客 阅读(28) 违法举报

这篇具有很好参考价值的文章主要介绍了Go 常用加密算法。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

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

Go 常用加密算法,Golang,# go从入门到精通,golang,哈希算法,开发语言
生成对应公钥:

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

Go 常用加密算法,Golang,# go从入门到精通,golang,哈希算法,开发语言

签名验签

私钥签名:

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("验签通过")
}

Go 常用加密算法,Golang,# go从入门到精通,golang,哈希算法,开发语言

加解密

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

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")))
}

Go 常用加密算法,Golang,# go从入门到精通,golang,哈希算法,开发语言
私钥解密：

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))
}

Go 常用加密算法,Golang,# go从入门到精通,golang,哈希算法,开发语言文章来源地址https://www.toymoban.com/news/detail-724056.html

到了这里，关于Go 常用加密算法的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【GoLang入门教程】Go语言工程结构详述

    【GoLang入门教程】Go语言工程结构详述

    前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站:人工智能 前言 当创建一个Go语言项目时，良好的工程结构是确保项目可维护性、可扩展性和清晰性的关键。 虽然Go本身没有强制性的项目结构要求，但是采用一致性

    2024年01月24日
    浏览(80)
  • 【Go语言】Golang保姆级入门教程 Go初学者chapter2

    【Go语言】Golang保姆级入门教程 Go初学者chapter2

    setting的首选项 一个程序就是一个世界 变量是程序的基本组成单位 变量的使用步骤 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zuxG8imp-1691479164956)(https://cdn.staticaly.com/gh/hudiework/img@main/image-20230726152905139.png)] 变量表示内存中的一个存储区 注意：

    2024年02月14日
    浏览(129)
  • 【Go语言】Golang保姆级入门教程 Go初学者chapter3

    【Go语言】Golang保姆级入门教程 Go初学者chapter3

    下划线“_”本身在Go中一个特殊的标识符，成为空标识符。可以代表任何其他的标识符，但是他对应的值就会被忽略 仅仅被作为站维度使用， 不能作为标识符使用 因为Go语言中没有private public 所以标记变量首字母大写代表其他包可以使用 小写就是不可使用的 注意：Go语言中

    2024年02月13日
    浏览(62)
  • 【Golang入门教程】Go语言变量的初始化

    【Golang入门教程】Go语言变量的初始化

    强烈推荐 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站: 人工智能 推荐一个个人工作，日常中比较常用的人工智能工具，无需魔法，忍不住分享一下给大家。点击跳转到网站: 人工智能工具 引言 在Go语言中，变量

    2024年04月17日
    浏览(79)
  • 【Go语言】Golang保姆级入门教程 Go初学者介绍chapter1

    【Go语言】Golang保姆级入门教程 Go初学者介绍chapter1

    Golang的学习方向 区块链研发工程师： 去中心化 虚拟货币 金融 Go服务器端、游戏软件工程师 ： C C++ 处理日志 数据打包 文件系统 数据处理 很厉害 处理大并发 Golang分布式、云计算软件工程师：盛大云 cdn 京东 消息推送 分布式文件系统 2、Golang的应用领域 区块链应用：区块链

    2024年02月15日
    浏览(70)
  • 【GoLang入门教程】Go语言几种标准库介绍(五)

    【GoLang入门教程】Go语言几种标准库介绍(五)

    前言 上一篇，我们介绍了fmt、Go、html 三个库，这篇我们继续介绍剩下的库 几种库 image库 (常见图形格式的访问及生成) 在 Go 语言的标准库中， image 包提供了对图像的基本操作和处理功能。 这个包定义了 Image 接口和一些基本的图像类型，同时也包含了一些实现了该接口的具

    2024年02月03日
    浏览(73)
  • 【GoLang入门教程】Go语言几种标准库介绍(六)

    【GoLang入门教程】Go语言几种标准库介绍(六)

    前言 上一篇，我们介绍了image、IO、math三个库，这篇我们继续介绍剩下的库 几种库 Net库 (网络库，支持 Socket、HTTP、邮件、RPC、SMTP 等) 在 Go 语言的标准库中， net 包提供了对网络操作的支持，包括基本的网络协议、Socket 编程、HTTP 客户端和服务器等。 net 包包含多个子包，其

    2024年02月02日
    浏览(62)
  • 【GoLang入门教程】Go语言几种标准库介绍(四)

    【GoLang入门教程】Go语言几种标准库介绍(四)

    前言 上一篇，我们介绍了debug、encoding、flag三个库，这篇我们继续介绍剩下的库 几种库 fmt库 (格式化操作) 在 Go 语言的标准库中， fmt 包提供了格式化输入输出的功能。 这个包包括了一系列函数，用于将数据格式化为字符串（ fmt.Sprintf ）、输出到控制台（ fmt.Print 、 fmt.Pri

    2024年02月03日
    浏览(106)
  • 【GoLang入门教程】Go语言几种标准库介绍(八)

    【GoLang入门教程】Go语言几种标准库介绍(八)

    强烈推荐 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站:人工智能 前言 上一篇，我们介绍了plugin、reflect、regexp三个库，这篇我们继续介绍剩下的库 几种库 runtime库 ( 运行时接口) 在 Go 语言的标准库中， runtime 包

    2024年01月19日
    浏览(66)
  • 【GoLang入门教程】Go语言几种标准库介绍(七)

    【GoLang入门教程】Go语言几种标准库介绍(七)

    前言 上一篇，我们介绍了Net、OS、path三个库，这篇我们继续介绍剩下的库 几种库 plugin库 (Go 1.7 加入的插件系统。支持将代码编译为插件，按需加载) 在 Go 语言的标准库中， plugin 包提供了对 Go 插件的支持。 插件是一种在运行时加载并与主程序交互的机制，允许程序在不重新

    2024年01月16日
    浏览(87)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包