首页 > 编程开发 > Go语言

Go语言实现对称加密和非对称加密的示例代码

来自：网络
时间：2024-03-30
阅读：

对称加密和非对称加密的区别主要有以下几个方面：

  • 1、密钥的使用：对称加密中，加密和解密使用的是同一个密钥，而非对称加密则使用两个不同的密钥，一般

    使用公钥进行加密，私钥进行解密。

  • 2、速度和效率：对称加密解密的速度比较快，适合数据比较长时的使用，而非对称加密和解密花费的时间

    长、速度相对较慢，只适合对少量数据的使用。

  • 3、安全性：对称加密的安全性相对较低，因为通信双方使用相同的秘钥，如果一方的秘钥遭泄露，那么整个

    通信就会被破解。而非对称加密使用一对秘钥，一个用来加密，一个用来解密，而且公钥是公开的，私钥是自

    己保存的，不需要像对称加密那样在通信之前要先同步秘钥，因此其安全性更好。

  • 4、密钥分发：在对称加密中，需要在通信双方之间安全地共享密钥。如果没有安全的通道来共享密钥，可能

    会被黑客截获，导致数据泄露。而非对称加密则不需要在通信之前共享密钥，因此更加安全。

在实际应用中，对称加密和非对称加密经常结合使用，以充分发挥它们各自的优点。例如，可以使用对称加密来加

密大量数据，然后使用非对称加密来安全地分发对称加密的密钥。

1、对称加密

1.1 AES

package main

import (
	"bytes"
	"crypto/aes"
	"crypto/cipher"
	"encoding/base64"
	"fmt"
)

// AES加密
func main() {
	// AES加密占16、24或32字节
	key := "12345678abcdefgh"
	// 加密的字符串
	str := "hello world!"
	fmt.Println("加密前的字符串:", str)
	cipherText, _ := SCEncryptString(str, key)
	fmt.Println("加密后的字符串:", cipherText)
	originalText, _ := SCDecryptString(cipherText, key)
	fmt.Println("解密后的字符串:", originalText)
}

// 对称加密
func SCEncrypt(originalBytes, key []byte) ([]byte, error) {
	// 1、实例化密码器block(参数为密钥)
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	blockSize := block.BlockSize()
	// 2、对明文进行填充(参数为原始字节切片和密码对象的区块个数)
	paddingBytes := PKCS5Padding(originalBytes, blockSize)
	// 3、实例化加密模式（参数为密码对象和密钥）
	blockMode := cipher.NewCBCEncrypter(block, key[:blockSize])
	// 4、对填充字节后的明文进行加密(参数为加密字节切片和填充字节切片)
	cipherBytes := make([]byte, len(paddingBytes))
	blockMode.CryptBlocks(cipherBytes, paddingBytes)
	return cipherBytes, nil
}

// 对称解密
func SCDecrypt(cipherBytes, key []byte) ([]byte, error) {
	// 1、实例化密码器block(参数为密钥)
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	blockSize := block.BlockSize()
	// 2、实例化解密模式（参数为密码对象和密钥）
	blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])
	// 3、对密文进行解密(参数为填充字节切片和加密字节切片)
	paddingBytes := make([]byte, len(cipherBytes))
	blockMode.CryptBlocks(paddingBytes, cipherBytes)
	// 4、去除填充的字节(参数为填充切片)
	originalBytes := PKCS5UnPadding(paddingBytes)
	return originalBytes, nil
}

// 封装字符串对称加密
func SCEncryptString(originalText, key string) (string, error) {
	cipherBytes, err := SCEncrypt([]byte(originalText), []byte(key))
	if err != nil {
		return "", err
	}
	// base64编码(encoded)
	base64str := base64.StdEncoding.EncodeToString(cipherBytes)
	return base64str, nil
}

// 封装字符串对称解密
func SCDecryptString(cipherText, key string) (string, error) {
	// base64解码(decode)
	cipherBytes, _ := base64.StdEncoding.DecodeString(cipherText)
	cipherBytes, err := SCDecrypt(cipherBytes, []byte(key))
	if err != nil {
		return "", err
	}
	return string(cipherBytes), nil
}

// 末尾填充字节
func PKCS5Padding(data []byte, blockSize int) []byte {
	// 要填充的值和个数
	padding := blockSize - len(data)%blockSize
	// 要填充的单个二进制值
	slice1 := []byte{byte(padding)}
	// 要填充的二进制数组
	slice2 := bytes.Repeat(slice1, padding)
	// 填充到数据末端
	return append(data, slice2...)
}

// 末尾填充0
func ZerosPadding(data []byte, blockSize int) []byte {
	// 要填充的个数
	padding := blockSize - len(data)%blockSize
	// 要填充的单个0数据
	slice1 := []byte{0}
	// 要填充的0二进制数组
	slice2 := bytes.Repeat(slice1, padding)
	// 填充到数据末端
	return append(data, slice2...)
}

// 去除填充的字节
func PKCS5UnPadding(data []byte) []byte {
	// 获取二进制数组最后一个数值
	unpadding := data[len(data)-1]
	// 截取开始至总长度减去填充值之间的有效数据
	result := data[:(len(data) - int(unpadding))]
	return result
}

// 去除填充的0
func ZerosUnPadding(data []byte) []byte {
	// 去除满足条件的子切片
	return bytes.TrimRightFunc(data, func(r rune) bool {
		return r == 0
	})
}

package main

import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"encoding/base64"
	"fmt"
	"io"
)

// AES加密
// AES加密占16、24或32字节
var encryptionKey = []byte("12345678abcdefgh")

func encrypt(data []byte) (string, error) {
	block, err := aes.NewCipher(encryptionKey)
	if err != nil {
		return "", err
	}

	ciphertext := make([]byte, aes.BlockSize+len(data))
	iv := ciphertext[:aes.BlockSize]
	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
		return "", err
	}

	stream := cipher.NewCFBEncrypter(block, iv)
	stream.XORKeyStream(ciphertext[aes.BlockSize:], data)

	return base64.URLEncoding.EncodeToString(ciphertext), nil
}

func decrypt(encodedData string) ([]byte, error) {
	ciphertext, err := base64.URLEncoding.DecodeString(encodedData)
	if err != nil {
		return nil, err
	}

	block, err := aes.NewCipher(encryptionKey)
	if err != nil {
		return nil, err
	}

	if len(ciphertext) < aes.BlockSize {
		return nil, fmt.Errorf("加密数据长度无效")
	}

	iv := ciphertext[:aes.BlockSize]
	ciphertext = ciphertext[aes.BlockSize:]

	stream := cipher.NewCFBDecrypter(block, iv)
	stream.XORKeyStream(ciphertext, ciphertext)

	return ciphertext, nil
}

func main() {
	data := []byte("Hello World!")
	encryptedData, err := encrypt(data)
	if err != nil {
		fmt.Println("加密失败:", err)
		return
	}

	fmt.Println("加密后的数据:", encryptedData)

	decryptedData, err := decrypt(encryptedData)
	if err != nil {
		fmt.Println("解密失败:", err)
		return
	}

	fmt.Println("解密后的数据:", string(decryptedData))
}

1.2 DES

package main

import (
	"bytes"
	"crypto/cipher"
	"crypto/des"
	"encoding/base64"
	"fmt"
)

// DES加密
func main() {
	// DES密钥占8字节
	key := "1234abcd"
	// 加密的字符串
	str := "hello world!"
	fmt.Println("加密前的字符串:", str)
	cipherText, _ := SCEncryptString(str, key)
	fmt.Println("加密后的字符串:", cipherText)
	originalText, _ := SCDecryptString(cipherText, key)
	fmt.Println("解密后的字符串:", originalText)
}

// 对称加密
func SCEncrypt(originalBytes, key []byte) ([]byte, error) {
	// 1、实例化密码器block(参数为密钥)
	block, err := des.NewCipher(key)
	if err != nil {
		return nil, err
	}
	blockSize := block.BlockSize()
	// 2、对明文进行填充(参数为原始字节切片和密码对象的区块个数)
	paddingBytes := PKCS5Padding(originalBytes, blockSize)
	// 3、实例化加密模式（参数为密码对象和密钥）
	blockMode := cipher.NewCBCEncrypter(block, key[:blockSize])
	// 4、对填充字节后的明文进行加密(参数为加密字节切片和填充字节切片)
	cipherBytes := make([]byte, len(paddingBytes))
	blockMode.CryptBlocks(cipherBytes, paddingBytes)
	return cipherBytes, nil
}

// 对称解密
func SCDecrypt(cipherBytes, key []byte) ([]byte, error) {
	// 1、实例化密码器block(参数为密钥)
	block, err := des.NewCipher(key)
	if err != nil {
		return nil, err
	}
	blockSize := block.BlockSize()
	// 2、实例化解密模式（参数为密码对象和密钥）
	blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])
	// 3、对密文进行解密(参数为填充字节切片和加密字节切片)
	paddingBytes := make([]byte, len(cipherBytes))
	blockMode.CryptBlocks(paddingBytes, cipherBytes)
	// 4、去除填充的字节(参数为填充切片)
	originalBytes := PKCS5UnPadding(paddingBytes)
	return originalBytes, nil
}

// 封装字符串对称加密
func SCEncryptString(originalText, key string) (string, error) {
	cipherBytes, err := SCEncrypt([]byte(originalText), []byte(key))
	if err != nil {
		return "", err
	}
	// base64编码(encoded)
	base64str := base64.StdEncoding.EncodeToString(cipherBytes)
	return base64str, nil
}

// 封装字符串对称解密
func SCDecryptString(cipherText, key string) (string, error) {
	// base64解码(decode)
	cipherBytes, _ := base64.StdEncoding.DecodeString(cipherText)
	cipherBytes, err := SCDecrypt(cipherBytes, []byte(key))
	if err != nil {
		return "", err
	}
	return string(cipherBytes), nil
}

// 末尾填充字节
func PKCS5Padding(data []byte, blockSize int) []byte {
	// 要填充的值和个数
	padding := blockSize - len(data)%blockSize
	// 要填充的单个二进制值
	slice1 := []byte{byte(padding)}
	// 要填充的二进制数组
	slice2 := bytes.Repeat(slice1, padding)
	// 填充到数据末端
	return append(data, slice2...)
}

// 末尾填充0
func ZerosPadding(data []byte, blockSize int) []byte {
	// 要填充的个数
	padding := blockSize - len(data)%blockSize
	// 要填充的单个0数据
	slice1 := []byte{0}
	// 要填充的0二进制数组
	slice2 := bytes.Repeat(slice1, padding)
	// 填充到数据末端
	return append(data, slice2...)
}

// 去除填充的字节
func PKCS5UnPadding(data []byte) []byte {
	// 获取二进制数组最后一个数值
	unpadding := data[len(data)-1]
	// 截取开始至总长度减去填充值之间的有效数据
	result := data[:(len(data) - int(unpadding))]
	return result
}

// 去除填充的0
func ZerosUnPadding(data []byte) []byte {
	// 去除满足条件的子切片
	return bytes.TrimRightFunc(data, func(r rune) bool {
		return r == 0
	})
}

package main

import (
	"crypto/cipher"
	"crypto/des"
	"crypto/rand"
	"encoding/base64"
	"fmt"
	"io"
)

// DES加密
// DES密钥占8字节
var encryptionKey = []byte("1234abcd")

func encrypt(data []byte) (string, error) {
	block, err := des.NewCipher(encryptionKey)
	if err != nil {
		return "", err
	}

	ciphertext := make([]byte, des.BlockSize+len(data))
	iv := ciphertext[:des.BlockSize]
	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
		return "", err
	}

	stream := cipher.NewCFBEncrypter(block, iv)
	stream.XORKeyStream(ciphertext[des.BlockSize:], data)

	return base64.URLEncoding.EncodeToString(ciphertext), nil
}

func decrypt(encodedData string) ([]byte, error) {
	ciphertext, err := base64.URLEncoding.DecodeString(encodedData)
	if err != nil {
		return nil, err
	}

	block, err := des.NewCipher(encryptionKey)
	if err != nil {
		return nil, err
	}

	if len(ciphertext) < des.BlockSize {
		return nil, fmt.Errorf("加密数据长度无效")
	}

	iv := ciphertext[:des.BlockSize]
	ciphertext = ciphertext[des.BlockSize:]

	stream := cipher.NewCFBDecrypter(block, iv)
	stream.XORKeyStream(ciphertext, ciphertext)

	return ciphertext, nil
}

func main() {
	data := []byte("Hello")
	encryptedData, err := encrypt(data)
	if err != nil {
		fmt.Println("加密失败:", err)
		return
	}

	fmt.Println("加密后的数据:", encryptedData)

	decryptedData, err := decrypt(encryptedData)
	if err != nil {
		fmt.Println("解密失败:", err)
		return
	}

	fmt.Println("解密后的数据:", string(decryptedData))
}

1.3 3DES

package main

import (
	"bytes"
	"crypto/cipher"
	"crypto/des"
	"encoding/base64"
	"fmt"
)

// 3DES加密
func main() {
	// 3DES密钥占24字节
	key := "abcdefghijklmn0123456789"
	// 加密的字符串
	str := "hello world!"
	fmt.Println("加密前的字符串:", str)
	cipherText, _ := SCEncryptString(str, key)
	fmt.Println("加密后的字符串:", cipherText)
	originalText, _ := SCDecryptString("3eS626HB2R9ZGcOAYLuWCw==", key)
	fmt.Println("解密后的字符串:", originalText)
}

// 对称加密
func SCEncrypt(originalBytes, key []byte) ([]byte, error) {
	// 1、实例化密码器block(参数为密钥)
	block, err := des.NewTripleDESCipher(key)
	if err != nil {
		return nil, err
	}
	blockSize := block.BlockSize()
	// 2、对明文进行填充(参数为原始字节切片和密码对象的区块个数)
	paddingBytes := PKCS5Padding(originalBytes, blockSize)
	// 3、实例化加密模式（参数为密码对象和密钥）
	blockMode := cipher.NewCBCEncrypter(block, key[:blockSize])
	// 4、对填充字节后的明文进行加密(参数为加密字节切片和填充字节切片)
	cipherBytes := make([]byte, len(paddingBytes))
	blockMode.CryptBlocks(cipherBytes, paddingBytes)
	return cipherBytes, nil
}

// 对称解密
func SCDecrypt(cipherBytes, key []byte) ([]byte, error) {
	// 1、实例化密码器block(参数为密钥)
	block, err := des.NewTripleDESCipher(key)
	if err != nil {
		return nil, err
	}
	blockSize := block.BlockSize()
	// 2、实例化解密模式（参数为密码对象和密钥）
	blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])
	// 3、对密文进行解密(参数为填充字节切片和加密字节切片)
	paddingBytes := make([]byte, len(cipherBytes))
	blockMode.CryptBlocks(paddingBytes, cipherBytes)
	// 4、去除填充的字节(参数为填充切片)
	originalBytes := PKCS5UnPadding(paddingBytes)
	return originalBytes, nil
}

// 封装字符串对称加密
func SCEncryptString(originalText, key string) (string, error) {
	cipherBytes, err := SCEncrypt([]byte(originalText), []byte(key))
	if err != nil {
		return "", err
	}
	// base64编码(encoded)
	base64str := base64.StdEncoding.EncodeToString(cipherBytes)
	return base64str, nil
}

// 封装字符串对称解密
func SCDecryptString(cipherText, key string) (string, error) {
	// base64解码(decode)
	cipherBytes, _ := base64.StdEncoding.DecodeString(cipherText)
	cipherBytes, err := SCDecrypt(cipherBytes, []byte(key))
	if err != nil {
		return "", err
	}
	return string(cipherBytes), nil
}

// 末尾填充字节
func PKCS5Padding(data []byte, blockSize int) []byte {
	// 要填充的值和个数
	padding := blockSize - len(data)%blockSize
	// 要填充的单个二进制值
	slice1 := []byte{byte(padding)}
	// 要填充的二进制数组
	slice2 := bytes.Repeat(slice1, padding)
	// 填充到数据末端
	return append(data, slice2...)
}

// 末尾填充0
func ZerosPadding(data []byte, blockSize int) []byte {
	// 要填充的个数
	padding := blockSize - len(data)%blockSize
	// 要填充的单个0数据
	slice1 := []byte{0}
	// 要填充的0二进制数组
	slice2 := bytes.Repeat(slice1, padding)
	// 填充到数据末端
	return append(data, slice2...)
}

// 去除填充的字节
func PKCS5UnPadding(data []byte) []byte {
	// 获取二进制数组最后一个数值
	unpadding := data[len(data)-1]
	// 截取开始至总长度减去填充值之间的有效数据
	result := data[:(len(data) - int(unpadding))]
	return result
}

// 去除填充的0
func ZerosUnPadding(data []byte) []byte {
	// 去除满足条件的子切片
	return bytes.TrimRightFunc(data, func(r rune) bool {
		return r == 0
	})
}

package main

import (
	"crypto/cipher"
	"crypto/des"
	"crypto/rand"
	"encoding/base64"
	"fmt"
	"io"
)

// 3DES加密
// 3DES密钥占24字节
var encryptionKey = []byte("abcdefghijklmn0123456789")

func encrypt(data []byte) (string, error) {
	block, err := des.NewTripleDESCipher(encryptionKey)
	if err != nil {
		return "", err
	}

	ciphertext := make([]byte, des.BlockSize+len(data))
	iv := ciphertext[:des.BlockSize]
	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
		return "", err
	}

	stream := cipher.NewCFBEncrypter(block, iv)
	stream.XORKeyStream(ciphertext[des.BlockSize:], data)

	return base64.URLEncoding.EncodeToString(ciphertext), nil
}

func decrypt(encodedData string) ([]byte, error) {
	ciphertext, err := base64.URLEncoding.DecodeString(encodedData)
	if err != nil {
		return nil, err
	}

	block, err := des.NewTripleDESCipher(encryptionKey)
	if err != nil {
		return nil, err
	}

	if len(ciphertext) < des.BlockSize {
		return nil, fmt.Errorf("加密数据长度无效")
	}

	iv := ciphertext[:des.BlockSize]
	ciphertext = ciphertext[des.BlockSize:]

	stream := cipher.NewCFBDecrypter(block, iv)
	stream.XORKeyStream(ciphertext, ciphertext)

	return ciphertext, nil
}

func main() {
	data := []byte("Hello")
	encryptedData, err := encrypt(data)
	if err != nil {
		fmt.Println("加密失败:", err)
		return
	}

	fmt.Println("加密后的数据:", encryptedData)

	decryptedData, err := decrypt(encryptedData)
	if err != nil {
		fmt.Println("解密失败:", err)
		return
	}

	fmt.Println("解密后的数据:", string(decryptedData))
}

2、非对称加密算法RSA

2.1 生成密钥对

生成密钥对，分别存储到公钥文件(public.pem)，私钥文件中(private.pem)。

package main

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

func main() {
	if err := GenerateRSAKey(); err != nil {
		log.Fatal("密钥生成失败!")
	}
	log.Println("密钥生成成功！")
}

// 生成密钥对并保存到文件
func GenerateRSAKey() error {
	// 1、RSA生成私钥文件的核心步骤
	// 1)、生成RSA密钥对
	// 密钥长度,默认值为1024位
	bits := 1024
	privateKer, err := rsa.GenerateKey(rand.Reader, bits)
	if err != nil {
		return err
	}
	// 2)、将私钥对象转换成DER编码形式
	derPrivateKer := x509.MarshalPKCS1PrivateKey(privateKer)
	// 3)、创建私钥pem文件
	file, err := os.Create("../certs/private.pem")
	if err != nil {
		return err
	}
	// 4)、对密钥信息进行编码,写入到私钥文件中
	block := &pem.Block{
		Type:  "RSA PRIVATE KEY",
		Bytes: derPrivateKer,
	}
	err = pem.Encode(file, block)
	if err != nil {
		return err
	}
	// 2、RSA生成公钥文件的核心步骤
	// 1)、生成公钥对象
	publicKey := &privateKer.PublicKey
	// 2)、将公钥对象序列化为DER编码格式
	derPublicKey, err := x509.MarshalPKIXPublicKey(publicKey)
	if err != nil {
		return err
	}
	// 3)、创建公钥pem文件
	file, err = os.Create("../certs/public.pem")
	if err != nil {
		return err
	}
	// 4)、对公钥信息进行编码,写入到公钥文件中
	block = &pem.Block{
		Type:  "PUBLIC KEY",
		Bytes: derPublicKey,
	}
	err = pem.Encode(file, block)
	if err != nil {
		return err
	}
	return nil
}

2.2 RSA加密解密过程

公钥加密，私钥解密。

加密过程：

  • 1、读取公钥文件，解析出公钥对象
  • 2、使用公钥对明文进行加密

解密过程：

  • 1、读取私钥文件，解析出公钥对象
  • 2、使用私钥对密文进行解密
package main

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

func main() {
	str := "Hello World!"
	encryptstr, _ := RSAEncryptString(str, "../certs/public.pem")
	fmt.Println(encryptstr)
	decrypt, _ := RSADecryptString(encryptstr, "../certs/private.pem")
	fmt.Println(decrypt)
}

// RSA加密字节数组,返回字节数组
func RSAEncrypt(originalBytes []byte, filename string) ([]byte, error) {
	// 1、读取公钥文件,解析出公钥对象
	publicKey, err := ReadParsePublicKey(filename)
	if err != nil {
		return nil, err
	}
	// 2、RSA加密,参数是随机数、公钥对象、需要加密的字节
	// Reader是一个全局共享的密码安全的强大的伪随机生成器
	return rsa.EncryptPKCS1v15(rand.Reader, publicKey, originalBytes)
}

// RSA解密字节数组,返回字节数组
func RSADecrypt(cipherBytes []byte, filename string) ([]byte, error) {
	// 1、读取私钥文件，解析出私钥对象
	privateKey, err := ReadParsePrivaterKey(filename)
	if err != nil {
		return nil, err
	}
	// 2、ras解密,参数是随机数、私钥对象、需要解密的字节
	return rsa.DecryptPKCS1v15(rand.Reader, privateKey, cipherBytes)
}

// 读取公钥文件,解析出公钥对象
func ReadParsePublicKey(filename string) (*rsa.PublicKey, error) {
	// 1、读取公钥文件,获取公钥字节
	publicKeyBytes, err := ioutil.ReadFile(filename)
	if err != nil {
		return nil, err
	}
	// 2、解码公钥字节,生成加密块对象
	block, _ := pem.Decode(publicKeyBytes)
	if block == nil {
		return nil, errors.New("公钥信息错误！")
	}
	// 3、解析DER编码的公钥,生成公钥接口
	publicKeyInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
	if err != nil {
		return nil, err
	}
	// 4、公钥接口转型成公钥对象
	publicKey := publicKeyInterface.(*rsa.PublicKey)
	return publicKey, nil
}

// 读取私钥文件,解析出私钥对象
func ReadParsePrivaterKey(filename string) (*rsa.PrivateKey, error) {
	// 1、读取私钥文件,获取私钥字节
	privateKeyBytes, err := ioutil.ReadFile(filename)
	if err != nil {
		return nil, err
	}
	// 2、对私钥文件进行编码,生成加密块对象
	block, _ := pem.Decode(privateKeyBytes)
	if block == nil {
		return nil, errors.New("私钥信息错误！")
	}
	// 3、解析DER编码的私钥,生成私钥对象
	privateKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
	if err != nil {
		return nil, err
	}
	return privateKey, nil
}

// RSA加密字符串,返回base64处理的字符串
func RSAEncryptString(originalText, filename string) (string, error) {
	cipherBytes, err := RSAEncrypt([]byte(originalText), filename)
	if err != nil {
		return "", err
	}
	return base64.StdEncoding.EncodeToString(cipherBytes), nil
}

// RSA解密经过base64处理的加密字符串,返回加密前的明文
func RSADecryptString(cipherlText, filename string) (string, error) {
	cipherBytes, _ := base64.StdEncoding.DecodeString(cipherlText)
	originalBytes, err := RSADecrypt(cipherBytes, filename)
	if err != nil {
		return "", err
	}
	return string(originalBytes), nil
}

2.3 数字签名验证

加密与签名的区别：

  • 加密：公钥加密，私钥解密
  • 签名：私钥签名，公钥验证

数字签名过程：

  • 原文的哈希值用自己私钥签名，原文+签名给对方，对方用公钥验证签名时与原文哈希比对。

加密并签名：

  • 原文用对方公钥加密，原文的哈希值用自己的私钥签名，密文+签名给对方，对方公钥验证签名和自己私钥解

    密原文的哈希值比对。

package main

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

func main() {
	str := "Hello World!"
	base64Sig, _ := RSASign([]byte(str), "../certs/private.pem")
	fmt.Println("签名后的信息：", base64Sig)
	err := RSAVerify([]byte(str), base64Sig, "../certs/public.pem")
	if err == nil {
		fmt.Println("验证成功！")
	} else {
		fmt.Println("验证失败！")
	}
}

// 私钥签名过程
func RSASign(data []byte, filename string) (string, error) {
	// 1、选择hash算法,对需要签名的数据进行hash运算
	myhash := crypto.SHA256
	hashInstance := myhash.New()
	hashInstance.Write(data)
	hashed := hashInstance.Sum(nil)
	// 2、读取私钥文件,解析出私钥对象
	privateKey, err := ReadParsePrivaterKey(filename)
	if err != nil {
		return "", err
	}
	// 3、RSA数字签名(参数是随机数、私钥对象、哈希类型、签名文件的哈希串),生成base64编码的签名字符串
	bytes, err := rsa.SignPKCS1v15(rand.Reader, privateKey, myhash, hashed)
	if err != nil {
		return "", err
	}
	return base64.StdEncoding.EncodeToString(bytes), nil
}

// 公钥验证签名过程
func RSAVerify(data []byte, base64Sig, filename string) error {
	// 1、对base64编码的签名内容进行解码,返回签名字节
	bytes, err := base64.StdEncoding.DecodeString(base64Sig)
	if err != nil {
		return err
	}
	// 2、选择hash算法,对需要签名的数据进行hash运算
	myhash := crypto.SHA256
	hashInstance := myhash.New()
	hashInstance.Write(data)
	hashed := hashInstance.Sum(nil)
	// 3、读取公钥文件,解析出公钥对象
	publicKey, err := ReadParsePublicKey(filename)
	if err != nil {
		return err
	}
	// 4、RSA验证数字签名(参数是公钥对象、哈希类型、签名文件的哈希串、签名后的字节)
	return rsa.VerifyPKCS1v15(publicKey, myhash, hashed, bytes)
}

// 读取公钥文件,解析出公钥对象
func ReadParsePublicKey(filename string) (*rsa.PublicKey, error) {
	// 1、读取公钥文件,获取公钥字节
	publicKeyBytes, err := ioutil.ReadFile(filename)
	if err != nil {
		return nil, err
	}
	// 2、解码公钥字节,生成加密块对象
	block, _ := pem.Decode(publicKeyBytes)
	if block == nil {
		return nil, errors.New("公钥信息错误！")
	}
	// 3、解析DER编码的公钥,生成公钥接口
	publicKeyInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
	if err != nil {
		return nil, err
	}
	// 4、公钥接口转型成公钥对象
	publicKey := publicKeyInterface.(*rsa.PublicKey)
	return publicKey, nil
}

// 读取私钥文件,解析出私钥对象
func ReadParsePrivaterKey(filename string) (*rsa.PrivateKey, error) {
	// 1、读取私钥文件，获取私钥字节
	privateKeyBytes, err := ioutil.ReadFile(filename)
	if err != nil {
		return nil, err
	}
	// 2、对私钥文件进行编码,生成加密块对象
	block, _ := pem.Decode(privateKeyBytes)
	if block == nil {
		return nil, errors.New("私钥信息错误！")
	}
	// 3、解析DER编码的私钥,生成私钥对象
	privateKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
	if err != nil {
		return nil, err
	}
	return privateKey, nil
}
最新文章 相关文章

从零封装Gin框架配置初始化全局变量

目录引言安装编写配置文件编写配置结构体全局变量使用 viper 载入配置初始化配置引言配置文件是每个项目必不可少的部分，用来保存应用基本数据、数据库配置等信息，避免要修改

2024-03-30 11:27:07

Go语言Gin框架获取请求参数的两种方式

目录引言传递参数的方式HeaderURLHTTP Body直接获取请求参数获取URL Path中的参数获取URL Query中的参数获取HTTP Body中的参数绑定请求参数绑定Header参数绑定URL Path参数

2024-03-30 11:27:05

go mod 依赖管理的具体使用

目录go mod 介绍mod 相关环境变量如何使用 go modgo.mod 文件go mod 命令go.mod 文件go get 升级go.sum不同模式的命令区别1. gopath模式2. go vendor模式2. go module模式

2024-03-30 11:27:03

Go语言实现对称加密和非对称加密的示例代码

目录1、对称加密1.1 AES1.2 DES1.3 3DES2、非对称加密算法RSA2.1 生成密钥对2.2 RSA加密解密过程2.3 数字签名验证对称加密和非对称加密的区别主要有以下几个方面：1、密钥的

2024-03-30 11:27:01

Golang token的生成和解析详解

Golang token的生成和解析使用第三方库来实现go get github.com/dgrijalva/jwt-gogolang代码package mainimport ( "fmt" "time" "github.com/dgrijalva/jwt-go")func main(

2024-03-30 11:23:24

Go Build编译打包文件的完整步骤

目录1、简单打包2、打包时为程序中的变量设置值3、打包时指定名称总结1、简单打包程序 main1.go：package mainimport "fmt"func main() { fmt.Println("Hello World!")}打包：#

2024-03-30 11:23:22

Go高级特性之并发处理http详解

目录引言使用 Goroutines 的基本方法Goroutine 入门并发 HTTP 请求的方法WaitGroupChannelsWorker Pools使用信号量限制 Goroutines那么，最好的方法是什么错误处理集中误差通

2024-03-30 11:23:21

golang通过http访问外部网址的操作方法

目录 get方式访问外部的接口 Post方式请求外部接口不同项目之前,通过http访问,进行数据沟通先设定一个接口,确认外部能访问到PHP写一个接口public function ceshi_return(){

2024-03-30 11:23:19

go编译so库让python引用编译后没有.h文件的问题

有时python需要引用go的一些开源库，这时就需要go编译成python可调用的库go代码package main//包必须是mainimport( "C"//需要C库的支持，方便类型转换)func main(){}//非常重要

2024-03-30 11:23:16

深入解析Go语言中crypto/subtle加密库

目录引言crypto/subtle库概览ConstantTimeCompare函数深入解析ConstantTimeSelect函数应用详解ConstantTimeLessOrEq函数实践指南安全编程实践性能优化与最佳实践与其他加密

2024-03-30 11:23:15

go依赖注入库samber/do使用示例讲解

目录介绍代码结构结论介绍以简单和高效而闻名的Go语言在其1.18版本中引入了泛型，这可以显着减少大量代码生成的需要，使该语言更加强大和灵活。如果您有兴趣， Go 泛型教程 是很

2024-03-30 11:23:13

手把手教你如何在Goland中创建和运行项目

目录前言创建新项目编辑运行/调试配置编写并运行代码总结前言在Go语言的开发过程中，选择一个合适的集成开发环境（IDE）是提高效率和编写可维护代码的关键一步。JetBrains的Golan

2024-03-30 11:23:11

Go实现字符串与数字的高效转换

目录引言1. 基本的字符串转数字方法2. 生成非可逆的数字标识3. 性能优化技巧4. 应用场景分析结语引言在软件开发的世界里，数据类型转换是一项基础而重要的技能。尤其在Go语言

2024-03-30 11:23:08

Golang中crypto/cipher加密标准库全面指南

目录引言Golang 和加密简介crypto/cipher 库概览使用 crypto/cipher 实现加密高级功能和技巧最佳实践和性能优化总结引言在现代软件开发领域，安全性是一个不容忽视的重要议题

2024-03-30 11:23:07

Go 1.22对net/http包的路由增强功能详解

目录引言方法匹配（Method Matching）通配符（Wildcards）路径前缀匹配优先规则兼容性API 变更小结引言Go 1.22 版本对 net/http 包的路由功能进行了增强，引入了方法匹配（method match

2024-03-30 11:23:05

深入理解Go高级并发模式编写更高效可扩展的应用程序

目录引言1. 基础Goroutine2. Channel和Select3. 高级模式: 工作池(Worker Pool)结论引言"并发不是并行，但使并行成为可能。" —— Rob Pike本文将深入探讨Go中的一

2024-03-30 11:23:03

golang实现ping命令的完整代码

目录golang实现ping命令（附：完整代码）1 ping原理：ICMP协议（Type+Code+checksum+ID+sequence）常见ICMP类型2 实现2.1 定义ICMP结构体2.2 计算校验和2.3 命令行参数2.4 发送ICMP包效

2024-03-30 11:23:01

Golang使用gofumpt进行代码格式化

目录更强的格式化：gofumpt赋值运算符后无空行函数体周围无空行函数应分隔 ) { ，缩进有助于提高可读性代码块中的单独语句（或注释）周围没有空行简单错误检查前无空行复合字面量应

2024-03-30 11:22:58

Go语言中常用语法编写与优化技巧小结

目录1. 利用 sync.Pool 减少内存分配2. 使用缓冲通道进行异步操作3. 利用 pprof 进行性能分析4. 使用 strings.Builder 进行字符串拼接5. 利用 time.After 避免 goroutine

2024-03-30 11:22:57

详解Go语言中init的使用与常见应用场景

目录init() 函数的执行时机与被引入包的 init() 函数init() 的使用场景命令行参数配置加载环境检查注册插件或服务注意点启动耗时依赖关系Go 中有一个特别的 init() 函数，它

2024-03-30 11:22:55

grpc-go如何通过context传递额外数据

使用 ctx.Value 从 context 读取数据// ValueFromIncomingContext returns the metadata value corresponding to the metadata// key from the incoming metadata if it ex

2024-03-30 11:22:52

golang beyla采集trace程序原理源码解析

目录一. 整体原理二. 监听uprobe/ServeHTTP三. 监听uprobe/roundTrip四. 监听uprobe/roundTrip_return一. 整体原理trace采集时，监听了golang应用程序的net/http中的函数：net/

2024-03-30 11:22:51

golang如何让string转int64

目录golang让string转int64go语言string、int、int64互相转换总结golang让string转int64在 Go 语言中，可以使用内置函数 strconv.ParseInt() 将字符串转为 int64 类型。具体

2024-03-30 11:22:49

Golang中crypto/ecdsa库实现数字签名和验证

目录引言crypto/ecdsa库概览基本功能安装和设置使用场景ECDSA原理简介椭圆曲线密码学基础ECDSA的工作原理安全性考虑Golang中ECDSA的实现密钥生成数字签名签名验证crypto/ec

2024-03-30 11:22:47

golang gc的内部优化

今天讲一个常见的gc compiler（也就是官方版本的go编译器和runtime）在垃圾回收的扫描标记阶段做的优化。我对这个优化的描述印象最深的是在bigcache的注释里，大致内容是如果map

2024-03-26 11:53:22

Golang错误解析：常见问题及解决方案

在软件开发中，错误处理是一个不可避免的问题。特别是在使用诸如Golang这样的编程语言时，对错误的处理更是至关重要。本文将讨论一些在Golang开发中常见的问题以及相应的解决方

2024-03-20 00:14:26

golang 依赖控制反转（IoC） 改进版

　　最近在开发基于golang下的cqrs框架 https://github.com/berkaroad/squat （陆续开发中，最近断了半年，懒了。。。）。这个框架依赖ioc框架，因为之前写了一个ioc，所以借此完善下，主

2024-03-19 23:24:22

golang sync.Map之如何设计一个并发安全的读写分离结构?

在 golang中，想要并发安全的操作map，可以使用sync.Map结构，sync.Map 是一个适合读多写少的数据结构，今天我们来看看它的设计思想，来看看为什么说它适合读多写少的场景。如下，是gol

2024-03-19 23:23:56

golang使用DockerFile正确用法指南

目录 问题背景 编写Dockerfile 创建镜像 运行容器 附：Go 使用Dockerfile构建项目 mod 报错处理 1.情景 2.一开始的Dockerfile 3.解决方案 4.修改后结果 总结 问题背景

2024-03-18 22:08:04

golang trace view 视图详解

大家好，我是蓝胖子，在golang中可以使用go pprof的工具对golang程序进行性能分析，其中通过go trace 命令生成的trace view视图对于我们分析系统延迟十分有帮助，鉴于当前对trace v

2024-03-17 23:15:04

热点内容

goland2020.2.x永久激活码破解详细教程亲测可用(Windows Linux Mac)
2020-11-25
解决Goland 提示 Unresolved reference 错误的问题
2020-12-15
golang gorm 计算字段和获取sum()值的实现
2020-12-19
golang判断net.Conn 是否已关闭的操作
2020-12-24
go日志系统logrus显示文件和行号的操作
2020-11-10
golang获取网卡信息操作
2020-12-24
Goland调节字体大小的设置(编辑区,terminal区,页面字体)
2020-12-21
GoAdminGroup/go-admin的安装和运行的教程详解
2020-09-29
golang gorm多条件筛选查询操作
2020-12-19
如何解决go语言输出中文乱码的问题
2020-12-29
返回顶部
顶部