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

    文章

    210

    浏览量

    25518

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

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

收藏 人收藏

    评论

    相关推荐

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

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

    C加密算法的实现

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

    基于FPGA的AES256光纤加密设计

    的性能。 作品的难点与创新点部分设计,将会在第四部分(软件设计与流程)中详细的阐述。 系统架构 1.AES加密算法 俄歇算法属于对称密码体制中的一种分组密码,有AES-128、192
    发表于 06-19 19:50

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

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

    请问ESP-IDF的WPA3-SAE的入网加密算法最耗时的是那个函数?

    请问ESP-IDF的WPA3-SAE的入网加密算法最耗时的是那个函数
    发表于 06-05 08:17

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

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

    加密狗是什么意思 加密狗怎么解除加密

    加密算法和技术,以确保软件的安全性和防止非法复制、盗版以及未经授权的使用。 加密狗可以看作是软件版权保护的一种授权策略,它将软件授权信息存储在硬件设备中,并要求用户必须插入加密狗才能正常运行软件。而具体的
    的头像 发表于 01-25 17:19 7898次阅读

    TC233/TC234系列中的HSM硬件支持哪些加密算法

    HSM 中支持的算法:你能否具体说明 TC233/TC234 系列中的 HSM 硬件支持哪些加密算法? 特别是,我有兴趣了解对 AES、CMAC、RSA、ECC 和 SHA 的支持。 2. 具有类似
    发表于 01-18 10:33

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

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

    加密芯片工作原理max32555

    加密芯片MAX32555是一种广泛应用的硬件加密设备,它采用先进的加密算法和技术,对数据进行加密解密操作,以确保数据传输和存储的安全性。本
    的头像 发表于 12-13 15:03 1939次阅读

    php加密方式有哪些

    PHP加密方式有许多种,以下是一些常用的加密方式: 对称加密 对称加密算法使用相同的密钥进行加密解密
    的头像 发表于 12-04 15:32 599次阅读

    21489可以在启动加载程序过程中将SPIFLASH中的程序按照一定的解密算法解密后,加载到内部RAM运行吗?

    解密算法解密后,加载到内部RAM运行?这样,只要将编译好的程序经过一定的加密算法处理后,再烧写到SPIFLASH中,就算别人能够读出程序也没什么作用。有没有这种功能或者实现方式?
    发表于 11-30 07:47

    浅谈芯片常用的解密

    关于解密设备其实是很多种工具,例如我们常常听说到得FIB设备,其实不能说FIB是解密设备,FIB是聚焦离子束设备,是在纳米级的对材料切割和连接的一种仪器,当然在微电子领域应用最多,如果使用FIB解密芯片,那么就是要对芯片电路进行
    的头像 发表于 11-08 11:45 846次阅读

    单片机解密是否损坏母片?

    损坏母片。在本文中,我将详尽、详实、细致地探讨这个问题,并对相关的问题和观点进行分析。 首先,我们需要了解什么是单片机解密。单片机解密是一种技术手段,旨在破解已经加密或保护的单片机内部代码和电路。通过
    的头像 发表于 11-07 10:18 613次阅读

    单片机解密失败有哪几点原因呢?

    硬件保护机制,这些机制旨在防止对芯片内部信息的非法访问。常见的硬件保护机制包括随机数生成器、系列芯片锁定,以及对Flash或EEPROM进行加密等。这些保护机制使得解密者在破解芯片时面临更大的挑战,导致解密失败。 2. 强大的
    的头像 发表于 11-07 10:17 805次阅读