前提

本文章我们是先读取的RSA文件，所以需要先生成RSA，并且保存在文件中，再进行加密

生成RSA公钥和密钥

如果没有公钥和密钥，可以先看看我上一篇文章
生成RSA公钥和密钥

读取文件

在加密前，我们需要读取RSA文件内容，关于读取文件内容，我封装了一个"获取文件内容"的方法：

1. // GetFileContent 获取文件内容
   
2. func GetFileContent(filePath string) (string, error) {
   
3.         file, err := os.Open(filePath)
   
4.         if err != nil {
   
5.                 return "", err
   
6.         }
   
7.         defer file.Close()
   
8.         inputReader := bufio.NewReader(file)
   
9.         s := ""
   
10.         for {
    
11.                 inputString, readerError := inputReader.ReadString('\n')
    
12.                 s = fmt.Sprintf("%s%s", s, inputString)
    
13.                 if readerError == io.EOF {
    
14.                         break
    
15.                 }
    
16.         }
    
17.         return s, nil
    
18. }

复制代码

因为我们要读取 公钥 和 密钥 两个文件，所以避免重复的代码，我们封装了这么个方法，避免重复的代码。

加密

1. package main
   
2. 
   
3. import (
   
4.         "crypto/rand"
   
5.         "crypto/rsa"
   
6.         "crypto/sha256"
   
7.         "crypto/x509"
   
8.         "demo-mall-api-user/internal/utils"
   
9.         "encoding/base64"
   
10.         "encoding/pem"
    
11.         "fmt"
    
12. )
    
13. 
    
14. func main() {
    
15.         // 定义目录和文件
    
16.         dirPath := "/app/rsa"
    
17.         fileName := "public.pem"
    
18.         filePath := fmt.Sprintf("%s/%s", dirPath, fileName)  // 拼接成完整的文件地址
    
19. 
    
20.         publicContent, err := utils.GetFileContent(filePath) // 读取文件内容
    
21.         if err != nil {
    
22.                 fmt.Println("读取公钥文件错误：", err.Error())
    
23.                 return
    
24.         }
    
25. 
    
26.         // 解析PEM格式的数据
    
27.         block, _ := pem.Decode([]byte(publicContent))
    
28.         if block == nil || block.Type != "PUBLIC KEY" {
    
29.                 fmt.Println("公钥类型错误")
    
30.                 return
    
31.         }
    
32. 
    
33.         // 解析公钥
    
34.         publicKey, _ := x509.ParsePKIXPublicKey(block.Bytes)
    
35.         // 类型断言为*rsa.PublicKey
    
36.         rsaPub, ok := publicKey.(*rsa.PublicKey)
    
37.         if !ok {
    
38.                 fmt.Println("public key is not RSA")
    
39.                 return
    
40.         }
    
41. 
    
42.         // 待加密的字符串
    
43.         message := []byte("Lucky")
    
44.         // 标签，可以为空，如果加密时定义了某个值，解密时也需要用相同的值
    
45.         label := []byte("")
    
46.         ciphertext, err := rsa.EncryptOAEP(sha256.New(), rand.Reader, rsaPub, message, label)
    
47. 
    
48.         // 转换为base64编码的字符串
    
49.         hexStr := base64.StdEncoding.EncodeToString(ciphertext)
    
50. 
    
51.         fmt.Println("加密前的数据：", string(message))
    
52.         fmt.Println("加密后：", hexStr)
    
53. }

复制代码

运行程序：

1. go run main.go

复制代码

会打印出：

以上，我们就得到了加密后的数据

解密

1. package main
   
2. 
   
3. import (
   
4.         "crypto/rand"
   
5.         "crypto/rsa"
   
6.         "crypto/sha256"
   
7.         "crypto/x509"
   
8.         "demo-mall-api-user/internal/utils"
   
9.         "encoding/base64"
   
10.         "encoding/pem"
    
11.         "fmt"
    
12.         "log"
    
13. )
    
14. 
    
15. func main() {
    
16.         // 定义目录和文件
    
17.         dirPath := "/app/rsa"
    
18.         fileName := "private.key"
    
19.         filePath := fmt.Sprintf("%s/%s", dirPath, fileName) // 拼接成完整的文件地址
    
20. 
    
21.         privateContent, err := utils.GetFileContent(filePath) // 读取文件内容
    
22.         if err != nil {
    
23.                 fmt.Println("读取密钥文件错误：", err.Error())
    
24.                 return
    
25.         }
    
26. 
    
27.         // 解析PEM格式的数据
    
28.         block, _ := pem.Decode([]byte(privateContent))
    
29.         if block == nil || block.Type != "RSA PRIVATE KEY" {
    
30.                 fmt.Println("私钥类型错误")
    
31.                 return
    
32.         }
    
33.         // 解析密钥
    
34.         privateKey, _ := x509.ParsePKCS1PrivateKey(block.Bytes)
    
35. 
    
36.         // 待解密的字符串
    
37.         encodedCiphertext := "BR8ixCEoG4/EW63VEf/lnBiATAaPIdH6OzxB96vSGewR+Dm98e1KcpPvvRoggw7GJfdk2gxlDN8kuk4BeoSxuKdIe9FupbY+V58k83ZWpyCY2anDYmFkBIog9dVddTR41ktxRp3+lr1+ztoZUivJMUerbqmarNvCwf/2ALQ/4Qn7bBZo4c0OPXHij9bOfaN+elBmqLMFB4DrCYdoNbU49i95XjziUv9wdLRLSTD+xnMxjc3jDAFTyhDgw9abdrqJgilAcPjXmsZhyqkcEOwCm16ZjGn+OmzarvC6O6aCClRYiTcGOg2utt4c5fDDRSoGqmeULu1971b7DpETThey3g=="
    
38. 
    
39.         // 标签，可以为空，如果加密时定义了某个值，解密时也需要用相同的值
    
40.         label := []byte("")
    
41. 
    
42.         // Base64编码的字符串解码
    
43.         ciphertext, err := base64.StdEncoding.DecodeString(encodedCiphertext)
    
44.         if err != nil {
    
45.                 log.Fatalf("failed to decode base64 ciphertext: %v", err)
    
46.                 return
    
47.         }
    
48. 
    
49.         // 使用私钥进行解密
    
50.         plaintext, err := rsa.DecryptOAEP(sha256.New(), rand.Reader, privateKey, ciphertext, label)
    
51.         if err != nil {
    
52.                 log.Fatalf("Error decrypting message: %s", err)
    
53.                 return
    
54.         }
    
55.         fmt.Println("解密前的数据：", encodedCiphertext)
    
56.         fmt.Println("解密后：", string(plaintext))
    
57. }

复制代码

运行程序：

1. go run main.go

复制代码

会打印出：

到此这篇关于golang使用RSA加密和解密的实现示例的文章就介绍到这了,更多相关golang RSA加密和解密内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：互联网
免责声明：如果侵犯了您的权益，请联系站长（1277306191@qq.com），我们会及时删除侵权内容，谢谢合作！