0
  • 聊天消息
  • 系统消息
  • 评论与回复
登录后你可以
  • 下载海量资料
  • 学习在线课程
  • 观看威廉希尔官方网站 视频
  • 写文章/发帖/加入社区
会员中心
创作中心

完善资料让更多小伙伴认识你,还能领取20积分哦,立即完善>

3天内不再提示

详细解读Go加密解密算法

马哥Linux运维 来源:思否开发者社区 作者:guyan0319 2021-07-29 17:37 次阅读

本文介绍了常用的加密算法,并对这些加密算法结合实际 golang 代码段进行了详细解读。

前言

加密解密在实际开发中应用比较广泛,常用加解密分为:“对称式”、“非对称式”和”数字签名“。

对称式:对称加密(也叫私钥加密)指加密和解密使用相同密钥的加密算法。具体算法主要有DES算法,3DES算法,TDEA算法,Blowfish算法,RC5算法,IDEA算法。

非对称加密(公钥加密):指加密和解密使用不同密钥的加密算法,也称为公私钥加密。具体算法主要有RSA、Elgamal、背包算法、Rabin、D-H、ECC(椭圆曲线加密算法)。

数字签名:数字签名是非对称密钥加密威廉希尔官方网站 与数字摘要威廉希尔官方网站 的应用。主要算法有md5、hmac、sha1等。

以下介绍golang语言主要的加密解密算法实现。

md5

MD5信息摘要算法是一种被广泛使用的密码散列函数,可以产生出一个128位(16进制,32个字符)的散列值(hash value),用于确保信息传输完整一致。

func GetMd5String(s string) string {

h := md5.New()

h.Write([]byte(s))

return hex.EncodeToString(h.Sum(nil))

}

hmac

HMAC是密钥相关的哈希运算消息认证码(Hash-based Message Authentication Code)的缩写,

它通过一个标准算法,在计算哈希的过程中,把key混入计算过程中。

和我们自定义的加salt算法不同,Hmac算法针对所有哈希算法都通用,无论是MD5还是SHA-1。采用Hmac替代我们自己的salt算法,可以使程序算法更标准化,也更安全。

示例

//key随意设置 data 要加密数据func Hmac(key, data string) string {

hash:= hmac.New(md5.New, []byte(key)) // 创建对应的md5哈希加密算法

hash.Write([]byte(data))

return hex.EncodeToString(hash.Sum([]byte(“”)))

}

func HmacSha256(key, data string) string {

hash:= hmac.New(sha256.New, []byte(key)) //创建对应的sha256哈希加密算法

hash.Write([]byte(data))

return hex.EncodeToString(hash.Sum([]byte(“”)))

}

sha1

SHA-1可以生成一个被称为消息摘要的160位(20字节)散列值,散列值通常的呈现形式为40个十六进制数。

func Sha1(data string) string {

sha1 := sha1.New()

sha1.Write([]byte(data))

return hex.EncodeToString(sha1.Sum([]byte(“”)))

}

AES

密码学中的高级加密标准(Advanced Encryption Standard,AES),又称Rijndael加密法,是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES(Data Encryption Standard),已经被多方分析且广为全世界所使用。AES中常见的有三种解决方案,分别为AES-128、AES-192和AES-256。如果采用真正的128位加密威廉希尔官方网站 甚至256位加密威廉希尔官方网站 ,蛮力攻击要取得成功需要耗费相当长的时间。

AES 有五种加密模式:

电码本模式(Electronic Codebook Book (ECB))、

密码分组链接模式(Cipher Block Chaining (CBC))、

计算器模式(Counter (CTR))、

密码反馈模式(Cipher FeedBack (CFB))

输出反馈模式(Output FeedBack (OFB))

ECB模式

出于安全考虑,golang默认并不支持ECB模式。

package main

import (

“crypto/aes”

“fmt”

func AESEncrypt(src []byte, key []byte) (encrypted []byte) {

cipher, _ := aes.NewCipher(generateKey(key))

length := (len(src) + aes.BlockSize) / aes.BlockSize

plain := make([]byte, length*aes.BlockSize)

copy(plain, src)

pad := byte(len(plain) - len(src))

for i := len(src); i 《 len(plain); i++ {

plain[i] = pad

}

encrypted = make([]byte, len(plain))

// 分组分块加密

for bs, be := 0, cipher.BlockSize(); bs 《= len(src); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {

cipher.Encrypt(encrypted[bs:be], plain[bs:be])

}

return encrypted

}

func AESDecrypt(encrypted []byte, key []byte) (decrypted []byte) {

cipher, _ := aes.NewCipher(generateKey(key))

decrypted = make([]byte, len(encrypted))

//

for bs, be := 0, cipher.BlockSize(); bs 《 len(encrypted); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {

cipher.Decrypt(decrypted[bs:be], encrypted[bs:be])

}

trim := 0

if len(decrypted) 》 0 {

trim = len(decrypted) - int(decrypted[len(decrypted)-1])

}

return decrypted[:trim]

}

func generateKey(key []byte) (genKey []byte) {

genKey = make([]byte, 16)

copy(genKey, key)

for i := 16; i 《 len(key); {

for j := 0; j 《 16 && i 《 len(key); j, i = j+1, i+1 {

genKey[j] ^= key[i]

}

}

return genKey

}

func main() {

source:=“hello world”

fmt.Println(“原字符:”,source)

//16byte密钥

key:=“1443flfsaWfdas”

encryptCode:=AESEncrypt([]byte(source),[]byte(key))

fmt.Println(“密文:”,string(encryptCode))

decryptCode:=AESDecrypt(encryptCode,[]byte(key))

fmt.Println(“解密:”,string(decryptCode))

}

CBC模式

package main

import(

“bytes”

“crypto/aes”

“fmt”

“crypto/cipher”

“encoding/base64”

func main() {

orig := “hello world”

key := “0123456789012345”

fmt.Println(“原文:”, orig)

encryptCode := AesEncrypt(orig, key)

fmt.Println(“密文:” , encryptCode)

decryptCode := AesDecrypt(encryptCode, key)

fmt.Println(“解密结果:”, decryptCode)

}

func AesEncrypt(orig string, key string) string {

// 转成字节数组

origData := []byte(orig)

k := []byte(key)

// 分组秘钥

// NewCipher该函数限制了输入k的长度必须为16, 24或者32

block, _ := aes.NewCipher(k)

// 获取秘钥块的长度

blockSize := block.BlockSize()

// 补全码

origData = PKCS7Padding(origData, blockSize)

// 加密模式

blockMode := cipher.NewCBCEncrypter(block, k[:blockSize])

// 创建数组

cryted := make([]byte, len(origData))

// 加密

blockMode.CryptBlocks(cryted, origData)

return base64.StdEncoding.EncodeToString(cryted)

}

func AesDecrypt(cryted string, key string) string {

// 转成字节数组

crytedByte, _ := base64.StdEncoding.DecodeString(cryted)

k := []byte(key)

// 分组秘钥

block, _ := aes.NewCipher(k)

// 获取秘钥块的长度

blockSize := block.BlockSize()

// 加密模式

blockMode := cipher.NewCBCDecrypter(block, k[:blockSize])

// 创建数组

orig := make([]byte, len(crytedByte))

// 解密

blockMode.CryptBlocks(orig, crytedByte)

// 去补全码

orig = PKCS7UnPadding(orig)

return string(orig)

}

//补码//AES加密数据块分组长度必须为128bit(byte[16]),密钥长度可以是128bit(byte[16])、192bit(byte[24])、256bit(byte[32])中的任意一个。func PKCS7Padding(ciphertext []byte, blocksize int) []byte {

padding := blocksize - len(ciphertext)%blocksize

padtext := bytes.Repeat([]byte{byte(padding)}, padding)

return append(ciphertext, padtext.。。)

}

//去码func PKCS7UnPadding(origData []byte) []byte {

length := len(origData)

unpadding := int(origData[length-1])

return origData[:(length - unpadding)]

}

CRT模式

package main

import (

“bytes”

“crypto/aes”

“crypto/cipher”

“fmt”

//加密func aesCtrCrypt(plainText []byte, key []byte) ([]byte, error) {

//1. 创建cipher.Block接口

block, err := aes.NewCipher(key)

if err != nil {

return nil, err

}

//2. 创建分组模式,在crypto/cipher包中

iv := bytes.Repeat([]byte(“1”), block.BlockSize())

stream := cipher.NewCTR(block, iv)

//3. 加密

dst := make([]byte, len(plainText))

stream.XORKeyStream(dst, plainText)

return dst, nil

}

func main() {

source:=“hello world”

fmt.Println(“原字符:”,source)

key:=“1443flfsaWfdasds”

encryptCode,_:=aesCtrCrypt([]byte(source),[]byte(key))

fmt.Println(“密文:”,string(encryptCode))

decryptCode,_:=aesCtrCrypt(encryptCode,[]byte(key))

fmt.Println(“解密:”,string(decryptCode))

}

CFB模式

package main

import (

“crypto/aes”

“crypto/cipher”

“crypto/rand”

“encoding/hex”

“fmt”

“io”

func AesEncryptCFB(origData []byte, key []byte) (encrypted []byte) {

block, err := aes.NewCipher(key)

if err != nil {

//panic(err)

}

encrypted = make([]byte, aes.BlockSize+len(origData))

iv := encrypted[:aes.BlockSize]

if _, err := io.ReadFull(rand.Reader, iv); err != nil {

//panic(err)

}

stream := cipher.NewCFBEncrypter(block, iv)

stream.XORKeyStream(encrypted[aes.BlockSize:], origData)

return encrypted

}

func AesDecryptCFB(encrypted []byte, key []byte) (decrypted []byte) {

block, _ := aes.NewCipher(key)

if len(encrypted) 《 aes.BlockSize {

panic(“ciphertext too short”)

}

iv := encrypted[:aes.BlockSize]

encrypted = encrypted[aes.BlockSize:]

stream := cipher.NewCFBDecrypter(block, iv)

stream.XORKeyStream(encrypted, encrypted)

return encrypted

}

func main() {

source:=“hello world”

fmt.Println(“原字符:”,source)

key:=“ABCDEFGHIJKLMNO1”//16位

encryptCode:=AesEncryptCFB([]byte(source),[]byte(key))

fmt.Println(“密文:”,hex.EncodeToString(encryptCode))

decryptCode:=AesDecryptCFB(encryptCode,[]byte(key))

fmt.Println(“解密:”,string(decryptCode))

}

OFB模式

package main

import (

“bytes”

“crypto/aes”

“crypto/cipher”

“crypto/rand”

“encoding/hex”

“fmt”

“io”

func aesEncryptOFB( data[]byte,key []byte) ([]byte, error) {

data = PKCS7Padding(data, aes.BlockSize)

block, _ := aes.NewCipher([]byte(key))

out := make([]byte, aes.BlockSize + len(data))

iv := out[:aes.BlockSize]

if _, err := io.ReadFull(rand.Reader, iv); err != nil {

return nil, err

}

stream := cipher.NewOFB(block, iv)

stream.XORKeyStream(out[aes.BlockSize:], data)

return out, nil

}

func aesDecryptOFB( data[]byte,key []byte) ([]byte, error) {

block, _ := aes.NewCipher([]byte(key))

iv := data[:aes.BlockSize]

data = data[aes.BlockSize:]

if len(data) % aes.BlockSize != 0 {

return nil, fmt.Errorf(“data is not a multiple of the block size”)

}

out := make([]byte, len(data))

mode := cipher.NewOFB(block, iv)

mode.XORKeyStream(out, data)

out= PKCS7UnPadding(out)

return out, nil

}

//补码//AES加密数据块分组长度必须为128bit(byte[16]),密钥长度可以是128bit(byte[16])、192bit(byte[24])、256bit(byte[32])中的任意一个。func PKCS7Padding(ciphertext []byte, blocksize int) []byte {

padding := blocksize - len(ciphertext)%blocksize

padtext := bytes.Repeat([]byte{byte(padding)}, padding)

return append(ciphertext, padtext.。。)

}

//去码func PKCS7UnPadding(origData []byte) []byte {

length := len(origData)

unpadding := int(origData[length-1])

return origData[:(length - unpadding)]

}

func main() {

source:=“hello world”

fmt.Println(“原字符:”,source)

key:=“1111111111111111”//16位 32位均可

encryptCode,_:=aesEncryptOFB([]byte(source),[]byte(key))

fmt.Println(“密文:”,hex.EncodeToString(encryptCode))

decryptCode,_:=aesDecryptOFB(encryptCode,[]byte(key))

fmt.Println(“解密:”,string(decryptCode))

}

RSA加密

首先使用openssl生成公私钥

package main

import (

“crypto/rand”

“crypto/rsa”

“crypto/x509”

“encoding/base64”

“encoding/pem”

“errors”

“fmt”

// 私钥生成//openssl genrsa -out rsa_private_key.pem 1024var privateKey = []byte(`

-----BEGIN RSA PRIVATE KEY-----

MIICWwIBAAKBgQDcGsUIIAINHfRTdMmgGwLrjzfMNSrtgIf4EGsNaYwmC1GjF/bM

h0Mcm10oLhNrKNYCTTQVGGIxuc5heKd1gOzb7bdTnCDPPZ7oV7p1B9Pud+6zPaco

qDz2M24vHFWYY2FbIIJh8fHhKcfXNXOLovdVBE7Zy682X1+R1lRK8D+vmQIDAQAB

AoGAeWAZvz1HZExca5k/hpbeqV+0+VtobMgwMs96+U53BpO/VRzl8Cu3CpNyb7HY

64L9YQ+J5QgpPhqkgIO0dMu/0RIXsmhvr2gcxmKObcqT3JQ6S4rjHTln49I2sYTz

7JEH4TcplKjSjHyq5MhHfA+CV2/AB2BO6G8limu7SheXuvECQQDwOpZrZDeTOOBk

z1vercawd+J9ll/FZYttnrWYTI1sSF1sNfZ7dUXPyYPQFZ0LQ1bhZGmWBZ6a6wd9

R+PKlmJvAkEA6o32c/WEXxW2zeh18sOO4wqUiBYq3L3hFObhcsUAY8jfykQefW8q

yPuuL02jLIajFWd0itjvIrzWnVmoUuXydwJAXGLrvllIVkIlah+lATprkypH3Gyc

YFnxCTNkOzIVoXMjGp6WMFylgIfLPZdSUiaPnxby1FNM7987fh7Lp/m12QJAK9iL

2JNtwkSR3p305oOuAz0oFORn8MnB+KFMRaMT9pNHWk0vke0lB1sc7ZTKyvkEJW0o

eQgic9DvIYzwDUcU8wJAIkKROzuzLi9AvLnLUrSdI6998lmeYO9x7pwZPukz3era

zncjRK3pbVkv0KrKfczuJiRlZ7dUzVO0b6QJr8TRAA==

-----END RSA PRIVATE KEY-----

`)

// 公钥: 根据私钥生成//openssl rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pemvar publicKey = []byte(`

-----BEGIN PUBLIC KEY-----

MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDcGsUIIAINHfRTdMmgGwLrjzfM

NSrtgIf4EGsNaYwmC1GjF/bMh0Mcm10oLhNrKNYCTTQVGGIxuc5heKd1gOzb7bdT

nCDPPZ7oV7p1B9Pud+6zPacoqDz2M24vHFWYY2FbIIJh8fHhKcfXNXOLovdVBE7Z

y682X1+R1lRK8D+vmQIDAQAB

-----END PUBLIC KEY-----

`)

// 加密func RsaEncrypt(origData []byte) ([]byte, error) {

//解密pem格式的公钥

block, _ := pem.Decode(publicKey)

if block == nil {

return nil, errors.New(“public key error”)

}

// 解析公钥

pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)

if err != nil {

return nil, err

}

// 类型断言

pub := pubInterface.(*rsa.PublicKey)

//加密

return rsa.EncryptPKCS1v15(rand.Reader, pub, origData)

}

// 解密func RsaDecrypt(ciphertext []byte) ([]byte, error) {

//解密

block, _ := pem.Decode(privateKey)

if block == nil {

return nil, errors.New(“private key error!”)

}

//解析PKCS1格式的私钥

priv, err := x509.ParsePKCS1PrivateKey(block.Bytes)

if err != nil {

return nil, err

}

// 解密

return rsa.DecryptPKCS1v15(rand.Reader, priv, ciphertext)

}

func main() {

data, _ := RsaEncrypt([]byte(“hello world”))

fmt.Println(base64.StdEncoding.EncodeToString(data))

origData, _ := RsaDecrypt(data)

fmt.Println(string(origData))

}

转自:guyan0319

segmentfault.com/a/1190000024557845

文章转载:思否开发者社区

(版权归原作者所有,侵删)

声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容侵权或者其他违规问题,请联系本站处理。 举报投诉
  • 加密算法
    +关注

    关注

    0

    文章

    215

    浏览量

    25545

原文标题:Go 加密解密算法总结

文章出处:【微信号:magedu-Linux,微信公众号:马哥Linux运维】欢迎添加关注!文章转载请注明出处。

收藏 人收藏

    评论

    相关推荐

    【RA-Eco-RA4E2-64PIN-V1.0开发板试用】RA4E2使用之AES128加密解密

    加密解密算法来进行解释和说明数据加密解密操作的。 AES(Advanced Encryption Standard)是对称
    发表于 12-23 17:29

    浅谈加密芯片的一种破解方法和对应加密方案改进设计

    ,只要破解了一种方式,那么只要使用这种逻辑加密芯片和这种加密方式的产品都很容易破解,就像上述破解方式,破解者不需要去破解加密芯片,只需要通过固定ID和随机数的方式就能绕开加解密
    发表于 12-20 15:31

    浅谈加密芯片的一种破解方法和加密方案改进设计

    破解了一种方式,那么只要使用这种逻辑加密芯片和这种加密方式的产品都很容易破解,就像上述破解方式,破解者不需要去破解加密芯片,只需要通过固定ID和随机数的方式就能绕开加解密
    发表于 12-20 15:10

    加密算法在云计算中如何应用?

    加密算法在云计算中的应用主要体现在以下几个方面: 数据加密 : 数据加密是保护数据在传输和存储过程中的机密性的关键威廉希尔官方网站 。在云计算中,数据加密威廉希尔官方网站 可以分为传输
    的头像 发表于 12-17 16:02 79次阅读

    加密算法的选择对于加密安全有多重要?

    加密算法的选择对于加密安全至关重要,因为它直接影响到数据保护的有效性和可靠性。以下是几个关键点来说明加密算法选择的重要性: 加密强度: 加密算法
    的头像 发表于 12-17 15:59 73次阅读

    常见的加密算法有哪些?它们各自的优势是什么?

    在于其出色的安全性能和高效的实现方式,已成为目前最广泛使用的加密算法之一。它能够抵御暴力破解攻击,且在各种硬件和软件平台上都能实现高效的加密解密操作。 DES(Data Encryption
    的头像 发表于 12-17 15:57 81次阅读

    华纳云:加密算法在保护网络安全中扮演什么角色

    。只有具有正确密钥的接收方才能解密数据并还原其原始形式。 数据完整性:加密算法可以用于计算和验证数据的完整性。通过使用哈希函数或数字签名算法,发送方可以生成数据的摘要或签名,并将其附加到数据上。接收方可以使用相
    的头像 发表于 12-06 15:22 158次阅读

    aes加密的常见错误及解决方案

    的归纳以及相应的解决方案: 常见错误 编码问题 : 在将字节数组转换成字符串时,如果使用了不同的编码格式,可能会导致解密后的数据出现乱码。 密钥长度问题 : AES算法支持128位、192位和256位三种密钥长度。如果加密
    的头像 发表于 11-14 15:13 1192次阅读

    socket 加密通信的实现方式

    握手过程协商加密算法、生成会话密钥。 数据传输: 使用协商的加密算法和会话密钥对数据进行加密解密。 结束握手: 通信结
    的头像 发表于 11-12 14:18 370次阅读

    4G模组加解密艺术:通用函数的深度解读

    今天是对加解密通用函数的深度解读,我将详细讲解,建议收藏,不可错过。
    的头像 发表于 11-12 09:58 233次阅读
    4G模组加<b class='flag-5'>解密</b>艺术:通用函数的深度<b class='flag-5'>解读</b>

    安卓APP开发中,如何使用加密芯片?

    加密芯片是一种专门设计用于保护信息安全的硬件设备,它通过内置的加密算法对数据进行加密解密,以防止敏感数据被窃取或篡改。如下图HD-RK3568-IOT工控板,搭载ATSHA204A
    的头像 发表于 10-31 17:43 385次阅读
    安卓APP开发中,如何使用<b class='flag-5'>加密</b>芯片?

    C加密算法的实现

    电子发烧友网站提供《C加密算法的实现.pdf》资料免费下载
    发表于 09-20 11:10 1次下载
    C<b class='flag-5'>加密算法</b>的实现

    鸿蒙开发接口安全:【@system.cipher (加密算法)】

    加密类型,可选项有: 1. encrypt 加密 2. decrypt 解密
    的头像 发表于 06-06 09:11 1027次阅读
    鸿蒙开发接口安全:【@system.cipher (<b class='flag-5'>加密算法</b>)】

    基于 FPGA 的光纤混沌加密系统

    加密解密两块来详细说明。 加密: 为了验证优化后 AES 算法功能的正确性,需要选取测试向量进行验证。我们 从官方的文档中获得参考基本功能
    发表于 04-26 17:18

    对称加密算法工作模式详解

    对称密码体制,又称为单密钥密码机制,其基本特征为加密密钥和解密密钥相同。
    的头像 发表于 01-04 11:25 2101次阅读
    对称<b class='flag-5'>加密算法</b>工作模式详解