Go语言实现对称加密算法AES、DES、3DES和非对称加密算法RSA
【摘要】
目录
1. 对称加密算法1.1 特点1.2 优缺点1.3 go语言实现对称加密算法1.3.1 AES1.3.2 DES1.3.3 DES (CBC模式)
2. 非对称加密算法2.1 ...
1. 对称加密算法
1.1 特点
- 加密和解密使用的是同一个密钥，数据私密性双向保证，也就是加密和解密都不能泄露密码
1.2 优缺点
- 优点：加密效率高，适合大些的数据加密
- 缺点：安全性相对非对称低
1.3 go语言实现对称加密算法
1.3.1 AES
AES-128：key长度16 字节
AES-192：key长度24 字节
AES-256：key长度32 字节
var key []byte = []byte("hallenhallenhall")
// 填充密码长度
func PadPwd(srcByte []byte,blockSize int) []byte {
// 16 13 13-3 = 10
padNum := blockSize - len(srcByte)%blockSize
ret := bytes.Repeat([]byte{byte(padNum)}, padNum)
srcByte = append(srcByte, ret...)
return srcByte
}
// 加密
func AesEncoding(src string) (string,error) {
srcByte := []byte(src)
fmt.Println(srcByte)
// safer
block, err := aes.NewCipher(key)
if err != nil {
return src, err
}
// 密码填充
NewSrcByte := PadPwd(srcByte, block.BlockSize()) //由于字节长度不够，所以要进行字节的填充
fmt.Println(NewSrcByte)
dst := make([]byte, len(NewSrcByte))
block.Encrypt(dst, NewSrcByte)
fmt.Println(dst)
// base64编码
pwd := base64.StdEncoding.EncodeToString(dst)
return pwd, nil
}
// 去掉填充的部分
func UnPadPwd(dst []byte) ([]byte,error) {
if len(dst) <= 0 {
return dst, errors.New("长度有误")
}
// 去掉的长度
unpadNum := int(dst[len(dst)-1])
return dst[:(len(dst) - unpadNum)], nil
}
// 解密
func AesDecoding(pwd string) (string,error) {
pwdByte := []byte(pwd)
pwdByte, err := base64.StdEncoding.DecodeString(pwd)
if err != nil {
return pwd, err
}
block, errBlock := aes.NewCipher(key)
if errBlock != nil {
return pwd, errBlock
}
dst := make([]byte, len(pwdByte))
block.Decrypt(dst, pwdByte)
dst, _ = UnPadPwd(dst) // 填充的要去掉
return string(dst), nil
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
1.3.2 DES
DES：支持字节长度是8
// 只支持8字节的长度
var desKey = []byte("hallenha")
// 加密
func DesEncoding(src string) (string,error) {
srcByte := []byte(src)
block, err := des.NewCipher(desKey)
if err != nil {
return src, err
}
// 密码填充
newSrcByte := PadPwd(srcByte, block.BlockSize())
dst := make([]byte, len(newSrcByte))
block.Encrypt(dst, newSrcByte)
// base64编码
pwd := base64.StdEncoding.EncodeToString(dst)
return pwd, nil
}
// 解密
func DesDecoding(pwd string) (string,error) {
pwdByte, err := base64.StdEncoding.DecodeString(pwd)
if err != nil {
return pwd, err
}
block, errBlock := des.NewCipher(desKey)
if errBlock != nil {
return pwd, errBlock
}
dst := make([]byte, len(pwdByte))
block.Decrypt(dst, pwdByte)
// 填充的要去掉
dst, _ = UnPadPwd(dst)
return string(dst), nil
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
1.3.3 DES (CBC模式)
des——CBC模式，key长度必须为24
// 3des的key，长度是24
var tdesKey = []byte("hallenhallenhallenhallen")
// 3des加密
func TDesEncoding(src string) (string,error) {
srcByte := []byte(src)
block, err := des.NewTripleDESCipher(tdesKey) // 和des的区别
if err != nil {
return src, err
}
// 密码填充
newSrcByte := PadPwd(srcByte, block.BlockSize())
dst := make([]byte, len(newSrcByte))
block.Encrypt(dst, newSrcByte)
// base64编码
pwd := base64.StdEncoding.EncodeToString(dst)
return pwd, nil
}
// 3des解密
func TDesDecoding(pwd string) (string,error) {
pwdByte, err := base64.StdEncoding.DecodeString(pwd)
if err != nil {
return pwd, err
}
block, errBlock := des.NewTripleDESCipher(tdesKey) // 和des的区别
if errBlock != nil {
return pwd, errBlock
}
dst := make([]byte, len(pwdByte))
block.Decrypt(dst, pwdByte)
// 填充的要去掉
dst, _ = UnPadPwd(dst)
return string(dst), nil
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
2. 非对称加密算法
2.1 特点
-
加密和解密的密钥不同，有两个密钥（公钥和私钥）
-
公钥：可以公开的密钥；公钥加密，私钥解密
-
私钥：私密的密钥；私钥加密，公钥解密
-
私密单方向保证，只要有一方不泄露就没问题
2.2 优缺点
-
优点：安全性相对对称加密高
-
缺点：加密效率低，适合小数据加密
2.3 go语言实现非对称加密算法
消息发送方利用对方的公钥进行加密，消息接受方收到密文时使用自己的私钥进行解密
对哪一方更重要，哪一方就拿私钥
注意：
公钥和密钥生成的时候要有一种关联，要把密钥和公钥保存起来。
2.3.1 RSA
package main
import (
"crypto/rand"
"crypto/rsa"
"crypto/x509"
"encoding/pem"
"fmt"
"os"
)
// 保存生成的公钥和密钥
func SaveRsaKey(bits int) error {
privateKey,err := rsa.GenerateKey(rand.Reader,bits)
if err != nil {
fmt.Println(err)
return err
}
publicKey := privateKey.PublicKey
// 使用x509标准对私钥进行编码，AsN.1编码字符串
x509Privete := x509.MarshalPKCS1PrivateKey(privateKey)
// 使用x509标准对公钥进行编码，AsN.1编码字符串
x509Public := x509.MarshalPKCS1PublicKey(&publicKey)
// 对私钥封装block 结构数据
blockPrivate := pem.Block{Type: "private key",Bytes: x509Privete}
// 对公钥封装block 结构数据
blockPublic := pem.Block{Type: "public key",Bytes: x509Public}
// 创建存放私钥的文件
privateFile, errPri := os.Create("privateKey.pem")
if errPri != nil {
return errPri
}
defer privateFile.Close()
pem.Encode(privateFile,&blockPrivate)
// 创建存放公钥的文件
publicFile, errPub := os.Create("publicKey.pem")
if errPub != nil {
return errPub
}
defer publicFile.Close()
pem.Encode(publicFile,&blockPublic)
return nil
}
// 加密
func RsaEncoding(src , filePath string) ([]byte,error){
srcByte := []byte(src)
// 打开文件
file,err := os.Open(filePath)
if err != nil {
return srcByte,err
}
// 获取文件信息
fileInfo, errInfo := file.Stat()
if errInfo != nil {
return srcByte, errInfo
}
// 读取文件内容
keyBytes := make([]byte, fileInfo.Size())
// 读取内容到容器里面
file.Read(keyBytes)
// pem解码
block,_ := pem.Decode(keyBytes)
// x509解码
publicKey , errPb := x509.ParsePKCS1PublicKey(block.Bytes)
if errPb != nil {
return srcByte, errPb
}
// 使用公钥对明文进行加密
retByte, errRet := rsa.EncryptPKCS1v15(rand.Reader,publicKey, srcByte)
if errRet != nil {
return srcByte, errRet
}
return retByte,nil
}
// 解密
func RsaDecoding(srcByte []byte,filePath string) ([]byte,error) {
// 打开文件
file,err := os.Open(filePath)
if err != nil {
return srcByte,err
}
// 获取文件信息
fileInfo,errInfo := file.Stat()
if errInfo != nil {
return srcByte,errInfo
}
// 读取文件内容
keyBytes := make([]byte,fileInfo.Size())
// 读取内容到容器里面
_, _ = file.Read(keyBytes)
// pem解码
block,_ := pem.Decode(keyBytes)
// x509解码
privateKey ,errPb := x509.ParsePKCS1PrivateKey(block.Bytes)
if errPb != nil {
return keyBytes,errPb
}
// 进行解密
retByte, errRet := rsa.DecryptPKCS1v15(rand.Reader,privateKey,srcByte)
if errRet != nil {
return srcByte,errRet
}
return retByte,nil
}
func main() {
//err := SaveRsaKey(2048)
//if err != nil {
// fmt.Println("KeyErr",err)
//}
msg, err := RsaEncoding("FanOne","publicKey.pem")
fmt.Println("msg",msg)
if err != nil {
fmt.Println("err1",err)
}
msg2,err := RsaDecoding(msg,"privateKey.pem")
if err != nil {
fmt.Println("err",err)
}
fmt.Println("msg2",string(msg2))
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
最后
小生凡一，期待你的关注。
文章来源: blog.csdn.net，作者：小生凡一，版权归原作者所有，如需转载，请联系作者。
原文链接：blog.csdn.net/weixin_45304503/article/details/118638349
【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）