golang公钥加密

什么是Golang公钥加密

Golang公钥加密是一种非对称加密算法，在Golang开发中被广泛应用于网络通信、文件传输等场景。与传统的对称加密算法不同，公钥加密使用一对密钥，包括公钥和私钥，来进行数据的加密和解密操作。

如何生成和使用公钥私钥

在Golang中，可以利用标准库crypto/rand生成随机的公钥私钥对。生成公私钥的示例代码如下：

package main

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"encoding/pem"
	"fmt"
	"os"
)

func generateRSAKey() (*rsa.PrivateKey, error) {
	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		return nil, err
	}

	return privateKey, nil
}

func savePrivateKey(privateKey *rsa.PrivateKey, fileName string) error {
	privateKeyFile, err := os.Create(fileName)
	if err != nil {
		return err
	}
	defer privateKeyFile.Close()

	privateKeyBytes := x509.MarshalPKCS1PrivateKey(privateKey)
	privateKeyPEM := &pem.Block{
		Type:  "RSA PRIVATE KEY",
		Bytes: privateKeyBytes,
	}

	err = pem.Encode(privateKeyFile, privateKeyPEM)
	if err != nil {
		return err
	}

	return nil
}


func main() {
	privateKey, err := generateRSAKey()
	if err != nil {
		fmt.Println("Failed to generate RSA key")
		return
	}

	err = savePrivateKey(privateKey, "./private.pem")
	if err != nil {
		fmt.Println("Failed to save private key")
		return
	}

	fmt.Println("Private key generated and saved")
}

上述代码会在当前目录生成一个名为private.pem的私钥文件，该文件包含了生成的私钥信息。

Golang公钥加密与解密

在使用Golang进行公钥加密和解密时，需要借助于标准库crypto/rsa和crypto/x509。

package main

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"encoding/pem"
	"fmt"
	"io/ioutil"
	"os"
)

func encrypt(plainText []byte, publicKey *rsa.PublicKey) ([]byte, error) {
	cipherText, err := rsa.EncryptPKCS1v15(rand.Reader, publicKey, plainText)
	if err != nil {
		return nil, err
	}

	return cipherText, nil
}

func decrypt(cipherText []byte, privateKey *rsa.PrivateKey) ([]byte, error) {
	plainText, err := rsa.DecryptPKCS1v15(rand.Reader, privateKey, cipherText)
	if err != nil {
		return nil, err
	}

	return plainText, nil
}

func loadPublicKey(fileName string) (*rsa.PublicKey, error) {
	publicKeyFile, err := os.Open(fileName)
	if err != nil {
		return nil, err
	}
	defer publicKeyFile.Close()

	publicKeyBytes, err := ioutil.ReadAll(publicKeyFile)
	if err != nil {
		return nil, err
	}

	block, _ := pem.Decode(publicKeyBytes)
	publicKey, err := x509.ParsePKCS1PublicKey(block.Bytes)
	if err != nil {
		return nil, err
	}

	return publicKey, nil
}

func main() {
	publicKey, err := loadPublicKey("./public.pem")
	if err != nil {
		fmt.Println("Failed to load public key")
		return
	}

	plainText := []byte("Hello, Golang!")

	cipherText, err := encrypt(plainText, publicKey)
	if err != nil {
		fmt.Println("Failed to encrypt")
		return
	}
	fmt.Printf("Cipher text: %x\n", cipherText)

	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		fmt.Println("Failed to generate RSA key")
		return
	}

	decryptedText, err := decrypt(cipherText, privateKey)
	if err != nil {
		fmt.Println("Failed to decrypt")
		return
	}
	fmt.Println("Decrypted text:", string(decryptedText))
}

上述代码演示了使用从文件中加载公钥，并对明文进行加密和解密操作。首先，通过loadPublicKey函数加载公钥文件；然后，调用encrypt函数对明文进行加密，返回密文；最后，通过decrypt函数对密文进行解密，返回明文。

小结

Golang公钥加密是保障数据安全的重要手段之一。通过生成公私钥对，并利用标准库实现加密解密操作，可以在Golang开发中实现数据的安全传输和存储。对于开发者来说，理解和掌握Golang公钥加密的原理和使用方法，对于保护数据的机密性具有重要意义。