Golang 实现自更新签名二进制文件管理的中央可信仓库插件库

下面我将介绍如何使用 Golang 实现一个自更新签名二进制文件管理的中央可信仓库插件库，主要使用 dbt (Database Toolkit) 作为基础。

核心设计思路

1. 使用数字签名确保二进制文件的完整性和来源可信
2. 中央仓库存储所有版本的二进制文件和对应的签名
3. 客户端能够自动检查更新并验证签名
4. 支持插件式架构，便于扩展功能

实现代码示例

package main

import (
	"crypto"
	"crypto/rsa"
	"crypto/sha256"
	"crypto/x509"
	"encoding/hex"
	"encoding/json"
	"encoding/pem"
	"errors"
	"fmt"
	"io"
	"net/http"
	"os"
	"path/filepath"
	"runtime"
	"time"
)

// BinaryInfo 存储二进制文件信息
type BinaryInfo struct {
	Version     string `json:"version"`
	DownloadURL string `json:"download_url"`
	SHA256      string `json:"sha256"`
	Signature   string `json:"signature"`
	ReleaseDate string `json:"release_date"`
}

// PluginManager 插件管理器
type PluginManager struct {
	repoURL      string
	publicKey    *rsa.PublicKey
	localVersion string
	binDir       string
}

// NewPluginManager 创建新的插件管理器
func NewPluginManager(repoURL, publicKeyPath, localVersion, binDir string) (*PluginManager, error) {
	pubKey, err := loadPublicKey(publicKeyPath)
	if err != nil {
		return nil, fmt.Errorf("failed to load public key: %v", err)
	}

	return &PluginManager{
		repoURL:      repoURL,
		publicKey:    pubKey,
		localVersion: localVersion,
		binDir:       binDir,
	}, nil
}

// loadPublicKey 加载公钥
func loadPublicKey(path string) (*rsa.PublicKey, error) {
	keyData, err := os.ReadFile(path)
	if err != nil {
		return nil, err
	}

	block, _ := pem.Decode(keyData)
	if block == nil {
		return nil, errors.New("failed to parse PEM block containing the public key")
	}

	pub, err := x509.ParsePKIXPublicKey(block.Bytes)
	if err != nil {
		return nil, err
	}

	return pub.(*rsa.PublicKey), nil
}

// CheckUpdate 检查更新
func (pm *PluginManager) CheckUpdate() (*BinaryInfo, error) {
	resp, err := http.Get(pm.repoURL + "/latest.json")
	if err != nil {
		return nil, fmt.Errorf("failed to fetch update info: %v", err)
	}
	defer resp.Body.Close()

	var info BinaryInfo
	if err := json.NewDecoder(resp.Body).Decode(&info); err != nil {
		return nil, fmt.Errorf("failed to decode update info: %v", err)
	}

	return &info, nil
}

// DownloadAndVerify 下载并验证二进制文件
func (pm *PluginManager) DownloadAndVerify(info *BinaryInfo) error {
	// 下载文件
	resp, err := http.Get(info.DownloadURL)
	if err != nil {
		return fmt.Errorf("failed to download binary: %v", err)
	}
	defer resp.Body.Close()

	// 创建临时文件
	tmpFile := filepath.Join(pm.binDir, fmt.Sprintf("temp_%d", time.Now().UnixNano()))
	out, err := os.Create(tmpFile)
	if err != nil {
		return fmt.Errorf("failed to create temp file: %v", err)
	}
	defer out.Close()

	// 计算SHA256并写入文件
	hasher := sha256.New()
	tee := io.TeeReader(resp.Body, hasher)

	if _, err := io.Copy(out, tee); err != nil {
		return fmt.Errorf("failed to write file: %v", err)
	}

	// 验证SHA256
	actualHash := hex.EncodeToString(hasher.Sum(nil))
	if actualHash != info.SHA256 {
		return fmt.Errorf("hash mismatch: expected %s, got %s", info.SHA256, actualHash)
	}

	// 验证签名
	signature, err := hex.DecodeString(info.Signature)
	if err != nil {
		return fmt.Errorf("failed to decode signature: %v", err)
	}

	hasher.Reset()
	if _, err := io.Copy(hasher, resp.Body); err != nil {
		return fmt.Errorf("failed to hash file: %v", err)
	}

	if err := rsa.VerifyPKCS1v15(pm.publicKey, crypto.SHA256, hasher.Sum(nil), signature); err != nil {
		return fmt.Errorf("signature verification failed: %v", err)
	}

	// 重命名为最终文件
	finalPath := filepath.Join(pm.binDir, fmt.Sprintf("plugin_v%s", info.Version))
	if err := os.Rename(tmpFile, finalPath); err != nil {
		return fmt.Errorf("failed to rename file: %v", err)
	}

	return nil
}

// AutoUpdate 自动更新流程
func (pm *PluginManager) AutoUpdate() error {
	latestInfo, err := pm.CheckUpdate()
	if err != nil {
		return err
	}

	if latestInfo.Version == pm.localVersion {
		fmt.Println("Already up to date")
		return nil
	}

	fmt.Printf("New version available: %s\n", latestInfo.Version)
	if err := pm.DownloadAndVerify(latestInfo); err != nil {
		return err
	}

	fmt.Println("Update successful")
	return nil
}

func main() {
	// 示例使用
	repoURL := "https://your-repository.com/plugins"
	publicKeyPath := "public_key.pem"
	localVersion := "1.0.0"
	binDir := "./bin"

	// 确保bin目录存在
	if err := os.MkdirAll(binDir, 0755); err != nil {
		fmt.Printf("Failed to create bin directory: %v\n", err)
		return
	}

	pm, err := NewPluginManager(repoURL, publicKeyPath, localVersion, binDir)
	if err != nil {
		fmt.Printf("Failed to create plugin manager: %v\n", err)
		return
	}

	if err := pm.AutoUpdate(); err != nil {
		fmt.Printf("Auto update failed: %v\n", err)
		return
	}
}

关键组件说明

1. 签名验证：

   • 使用 RSA 公私钥对进行签名验证
   • 下载文件时同时验证 SHA256 哈希和数字签名

2. 版本管理：

   • 中央仓库存储最新版本的元数据 (latest.json)
   • 客户端比较本地版本与远程版本

3. 安全下载：

   • 使用临时文件下载，验证通过后才重命名为正式文件
   • 支持断点续传和完整性检查

4. 插件架构：

   • 插件管理器负责核心更新逻辑
   • 可以扩展支持不同的存储后端和验证方式

部署建议

1. 中央仓库：

   • 使用 HTTPS 提供文件下载
   • 定期轮换签名密钥
   • 维护版本历史记录

2. 客户端：

   • 安全存储公钥
   • 实现定期自动检查更新
   • 提供回滚机制

3. 监控：

   • 记录更新操作日志
   • 上报更新失败情况

这个实现提供了基本框架，可以根据实际需求扩展更多功能，如多平台支持、增量更新、灰度发布等。