生成非对称密钥

package main

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

// MakePem 生成 PEM 文件
func MakePem() {
	// 生成 RSA 密钥对
	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		panic(err)
	}

	// 将私钥写入文件
	privateFile, err := os.Create("private.pem")
	if err != nil {
		panic(err)
	}
	defer privateFile.Close()
	privateBytes := x509.MarshalPKCS1PrivateKey(privateKey)
	privateBlock := &pem.Block{
		Type:  "RSA PRIVATE KEY",
		Bytes: privateBytes,
	}
	if err := pem.Encode(privateFile, privateBlock); err != nil {
		panic(err)
	}

	// 提取公钥并写入文件
	publicKey := &privateKey.PublicKey
	publicBytes, err := x509.MarshalPKIXPublicKey(publicKey)
	if err != nil {
		panic(err)
	}
	publicBlock := &pem.Block{
		Type:  "RSA PUBLIC KEY",
		Bytes: publicBytes,
	}
	publicFile, err := os.Create("public.pem")
	if err != nil {
		panic(err)
	}
	defer publicFile.Close()
	if err := pem.Encode(publicFile, publicBlock); err != nil {
		panic(err)
	}

	println("密钥生成成功")
}

func main() {
	MakePem()
}

使用私钥来加密license

这里与其他非对称加密还不同，其他地方基本都是公钥加密，然后私钥解密

但是这里是私钥加密，然后公钥解密

这主要是为了保证license无法被篡改，而被解密倒相对次要一点

package main

import (
	"bytes"
	"crypto"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"crypto/x509"
	"encoding/gob"
	"encoding/pem"
	"fmt"
	"os"
	"time"
)

var (
	Username = "admin"
	Secret   = "secret-key-123"
)

type License struct {
	Username   string    `json:"username"`            // 用户名
	Secret     string    `json:"secret"`              // 密钥
	Expiration time.Time `json:"expiration"`          // 到期时间
	Signature  []byte    `json:"signature,omitempty"` // 签名
}

// 签名许可证
func signLicense(license *License, privateKey *rsa.PrivateKey) ([]byte, error) {
	licenseCopy := *license
	licenseCopy.Signature = nil // 签名前移除签名字段

	// 使用gob编码
	var licenseData []byte
	buffer := new(bytes.Buffer)
	encoder := gob.NewEncoder(buffer)
	if err := encoder.Encode(licenseCopy); err != nil {
		return nil, err
	}
	licenseData = buffer.Bytes()

	hash := sha256.Sum256(licenseData)
	signature, err := rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA256, hash[:])
	if err != nil {
		return nil, err
	}
	return signature, nil
}

var (
	license = &License{
		Username:   Username,
		Secret:     Secret,
		Expiration: time.Now().Add(30 * 24 * time.Hour), // 30 天后过期
	}
)

func MakeLicense() {
	// 读取私钥
	privateKeyData, err := os.ReadFile("private.pem")
	if err != nil {
		panic(err)
	}
	privateBlock, _ := pem.Decode(privateKeyData)
	privateKey, err := x509.ParsePKCS1PrivateKey(privateBlock.Bytes)
	if err != nil {
		panic(err)
	}

	// 签名许可证
	signature, err := signLicense(license, privateKey)
	if err != nil {
		panic(err)
	}
	license.Signature = signature

	// 将许可证编码为二进制格式
	file, err := os.Create("license.lic")
	if err != nil {
		panic(err)
	}
	defer file.Close()

	encoder := gob.NewEncoder(file)
	if err := encoder.Encode(license); err != nil {
		panic(err)
	}

	fmt.Println("可证文件生成成功")
}

func main() {
	MakeLicense()
}

这里的license信息比较简单，只有用户名，用户密钥，有效时间以及license的签名，也可以自己更具业务需要添加其他信息

使用公钥校验license

package main

import (
	"bytes"
	"crypto"
	"crypto/rsa"
	"crypto/sha256"
	"crypto/x509"
	"encoding/gob"
	"encoding/pem"
	"fmt"
	"os"
	"time"
)

var (
	Username = "admin"
	Secret   = "secret-key-123"
)

// 验证许可证签名
func verifyLicense(license *License, publicKey *rsa.PublicKey) error {
	licenseCopy := *license
	licenseCopy.Signature = nil

	var buffer bytes.Buffer
	encoder := gob.NewEncoder(&buffer)
	err := encoder.Encode(licenseCopy)
	if err != nil {
		return err
	}
	licenseData := buffer.Bytes()

	hash := sha256.Sum256(licenseData)
	return rsa.VerifyPKCS1v15(publicKey, crypto.SHA256, hash[:], license.Signature)
}

func CheckLicense() {
	// 读取公钥
	publicKeyData, err := os.ReadFile("public.pem")
	if err != nil {
		panic(err)
	}
	publicBlock, _ := pem.Decode(publicKeyData)
	publicKey, err := x509.ParsePKIXPublicKey(publicBlock.Bytes)
	if err != nil {
		panic(err)
	}
	rsaPublicKey, ok := publicKey.(*rsa.PublicKey)
	if !ok {
		panic("不是 RSA 公钥")
	}

	// 读取二进制许可证
	licenseData, err := os.ReadFile("license.lic")
	if err != nil {
		fmt.Println("未找到许可证文件")
		return
	}

	var license License
	buffer := bytes.NewBuffer(licenseData)
	decoder := gob.NewDecoder(buffer)
	err = decoder.Decode(&license)
	if err != nil {
		fmt.Println("解析许可证文件失败")
		return
	}

	// 验证签名
	err = verifyLicense(&license, rsaPublicKey)
	if err != nil {
		fmt.Println("许可证验证失败:", err)
		return
	}

	// 检查过期时间 这里是使用本地时间校验的，也可以通过网络时间校验
	if time.Now().After(license.Expiration) {
		fmt.Println("许可证已过期")
		return
	}

	// 检查用户名
	if !(license.Username == Username && license.Secret == Secret) {
		fmt.Println("许可证无效")
		return
	}

	fmt.Printf("许可证有效，程序可以运行，有效期至%s\n", license.Expiration.Format("2006-01-02 15:04:05"))
	// 你的应用程序逻辑在这里
}

func main() {
	CheckLicense()
}

这里是通过本地时间来校验的有效性

这样做是有风险的，因为只要修改本地时间，就可以永远保证程序的有效性，这就导致license失去了意义

所以，可以通过网络时间来校验

或者循环检查本地时间，如果发现与网络时间相差太大，就不再允许使用程序

还有这里的用户名和密钥，可以通过网络进行校验，可以保证对程序的严格控制