759 lines
36 KiB
Markdown
759 lines
36 KiB
Markdown
# MPC 分布式签名系统 - 架构设计文档
|
|
|
|
## 1. 系统概述
|
|
|
|
本系统是一个基于多方安全计算 (MPC) 的分布式门限签名系统，支持 t-of-n 阈值签名方案。系统采用 **DDD (领域驱动设计) + 六边形架构 (Hexagonal Architecture) + 微服务** 的架构模式，使用 Go 语言开发，基于 bnb-chain/tss-lib 实现 TSS (Threshold Signature Scheme) 协议。
|
|
|
|
### 1.1 核心特性
|
|
|
|
- **门限签名**: 支持任意 t-of-n 阈值方案 (如 2-of-3, 3-of-5, 4-of-7)
|
|
- **分布式密钥生成 (DKG)**: 无需可信第三方生成密钥
|
|
- **ECDSA secp256k1**: 与以太坊/比特币兼容的签名算法
|
|
- **高安全性**: 密钥分片加密存储，单点泄露不影响安全性
|
|
- **微服务架构**: 可独立扩展和部署
|
|
- **Clean Architecture**: DDD + 六边形架构，领域逻辑与基础设施解耦
|
|
|
|
### 1.2 技术栈
|
|
|
|
| 层级 | 技术选型 |
|
|
|------|---------|
|
|
| 语言 | Go 1.21+ |
|
|
| TSS 库 | bnb-chain/tss-lib/v2 |
|
|
| 通信协议 | gRPC + HTTP/REST |
|
|
| 数据库 | PostgreSQL |
|
|
| 缓存 | Redis |
|
|
| 消息队列 | RabbitMQ |
|
|
| 服务发现 | Consul |
|
|
| 容器化 | Docker + Docker Compose |
|
|
| 架构模式 | DDD + Hexagonal + Microservices |
|
|
|
|
### 1.3 架构设计原则
|
|
|
|
| 原则 | 说明 |
|
|
|------|------|
|
|
| **依赖倒置** | 内层定义接口，外层实现；依赖指向内层 |
|
|
| **领域隔离** | Domain 层零外部依赖，纯业务逻辑 |
|
|
| **端口适配** | 通过 Port/Adapter 模式解耦 I/O |
|
|
| **服务自治** | 每个微服务独立部署、独立数据库 |
|
|
| **单一职责** | 每个服务只负责一个业务领域 |
|
|
|
|
## 2. 软件架构模式
|
|
|
|
### 2.1 DDD + 六边形架构 + 微服务
|
|
|
|
本系统采用三层架构模式的组合：
|
|
|
|
```
|
|
┌─────────────────────────────────────────────────────────────────────────────┐
|
|
│ 微服务架构 (Microservices) │
|
|
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │
|
|
│ │ Account Service │ │Session Coordinator│ │ Message Router │ ... │
|
|
│ │ (独立部署) │ │ (独立部署) │ │ (独立部署) │ │
|
|
│ └────────┬────────┘ └────────┬────────┘ └────────┬────────┘ │
|
|
│ │ │ │ │
|
|
│ ▼ ▼ ▼ │
|
|
│ ┌─────────────────────────────────────────────────────────────────────┐ │
|
|
│ │ 六边形架构 (Hexagonal / Ports & Adapters) │ │
|
|
│ │ │ │
|
|
│ │ ┌─────────────────────────────────────────────────────────────┐ │ │
|
|
│ │ │ Adapters (Input) │ │ │
|
|
│ │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │
|
|
│ │ │ │HTTP Handler │ │gRPC Handler │ │ 消息消费者 │ │ │ │
|
|
│ │ │ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │ │ │
|
|
│ │ └─────────┼────────────────┼────────────────┼──────────────────┘ │ │
|
|
│ │ │ │ │ │ │
|
|
│ │ ▼ ▼ ▼ │ │
|
|
│ │ ┌─────────────────────────────────────────────────────────────┐ │ │
|
|
│ │ │ Application Layer │ │ │
|
|
│ │ │ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ │ │
|
|
│ │ │ │ Input Ports │ │ Use Cases │ │ Output Ports │ │ │ │
|
|
│ │ │ │ (接口定义) │ │ (业务编排) │ │ (接口定义) │ │ │ │
|
|
│ │ │ └──────────────┘ └──────────────┘ └──────────────┘ │ │ │
|
|
│ │ └─────────────────────────────────────────────────────────────┘ │ │
|
|
│ │ │ │ │ │ │
|
|
│ │ ▼ ▼ ▼ │ │
|
|
│ │ ┌─────────────────────────────────────────────────────────────┐ │ │
|
|
│ │ │ Domain Layer (DDD) │ │ │
|
|
│ │ │ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ │ │
|
|
│ │ │ │ Entities │ │Value Objects │ │Domain Services│ │ │ │
|
|
│ │ │ │ (实体) │ │ (值对象) │ │ (领域服务) │ │ │ │
|
|
│ │ │ └──────────────┘ └──────────────┘ └──────────────┘ │ │ │
|
|
│ │ │ ┌──────────────┐ ┌──────────────┐ │ │ │
|
|
│ │ │ │ Repositories │ │ Aggregates │ │ │ │
|
|
│ │ │ │ (仓储接口) │ │ (聚合根) │ │ │ │
|
|
│ │ │ └──────────────┘ └──────────────┘ │ │ │
|
|
│ │ └─────────────────────────────────────────────────────────────┘ │ │
|
|
│ │ │ │ │ │ │
|
|
│ │ ▼ ▼ ▼ │ │
|
|
│ │ ┌─────────────────────────────────────────────────────────────┐ │ │
|
|
│ │ │ Adapters (Output) │ │ │
|
|
│ │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │
|
|
│ │ │ │ PostgreSQL │ │ Redis │ │ RabbitMQ │ │ │ │
|
|
│ │ │ │ Repo │ │ Cache │ │ Publisher │ │ │ │
|
|
│ │ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │ │
|
|
│ │ └─────────────────────────────────────────────────────────────┘ │ │
|
|
│ └─────────────────────────────────────────────────────────────────────┘ │
|
|
└─────────────────────────────────────────────────────────────────────────────┘
|
|
```
|
|
|
|
### 2.2 单个微服务内部结构
|
|
|
|
每个微服务采用六边形架构，内部分为三层：
|
|
|
|
```
|
|
service/
|
|
├── domain/ # 领域层 (最内层，零外部依赖)
|
|
│ ├── entities/ # 实体 - 有唯一标识的领域对象
|
|
│ ├── value_objects/ # 值对象 - 无标识的不可变对象
|
|
│ ├── repositories/ # 仓储接口 - 领域定义，适配器实现
|
|
│ └── services/ # 领域服务 - 跨实体的业务逻辑
|
|
│
|
|
├── application/ # 应用层 (中间层，编排业务用例)
|
|
│ ├── ports/ # 端口定义
|
|
│ │ ├── input/ # 入站端口 - 定义用例接口
|
|
│ │ └── output/ # 出站端口 - 定义基础设施接口
|
|
│ └── use_cases/ # 用例实现 - 业务流程编排
|
|
│
|
|
├── adapters/ # 适配器层 (最外层，处理 I/O)
|
|
│ ├── input/ # 入站适配器
|
|
│ │ ├── http/ # HTTP/REST 处理器
|
|
│ │ └── grpc/ # gRPC 处理器
|
|
│ └── output/ # 出站适配器
|
|
│ ├── postgres/ # PostgreSQL 仓储实现
|
|
│ ├── redis/ # Redis 缓存实现
|
|
│ └── rabbitmq/ # RabbitMQ 消息发布
|
|
│
|
|
└── cmd/server/ # 服务入口 - 依赖注入和启动
|
|
└── main.go
|
|
```
|
|
|
|
### 2.3 DDD 战术模式实现
|
|
|
|
#### 2.3.1 实体 (Entity)
|
|
|
|
有唯一标识的领域对象，封装业务规则：
|
|
|
|
```go
|
|
// services/account/domain/entities/account.go
|
|
type Account struct {
|
|
ID value_objects.AccountID // 唯一标识
|
|
Username string
|
|
Email string
|
|
PublicKey []byte
|
|
Status value_objects.AccountStatus
|
|
ThresholdN int
|
|
ThresholdT int
|
|
CreatedAt time.Time
|
|
UpdatedAt time.Time
|
|
}
|
|
|
|
// 业务方法封装在实体内
|
|
func (a *Account) Suspend() error {
|
|
if a.Status == value_objects.AccountStatusRecovering {
|
|
return ErrAccountInRecovery
|
|
}
|
|
a.Status = value_objects.AccountStatusSuspended
|
|
a.UpdatedAt = time.Now().UTC()
|
|
return nil
|
|
}
|
|
|
|
func (a *Account) CanLogin() bool {
|
|
return a.Status.CanLogin()
|
|
}
|
|
```
|
|
|
|
#### 2.3.2 值对象 (Value Object)
|
|
|
|
无标识的不可变对象，通过值相等性比较：
|
|
|
|
```go
|
|
// services/account/domain/value_objects/account_id.go
|
|
type AccountID struct {
|
|
value uuid.UUID
|
|
}
|
|
|
|
func NewAccountID() AccountID {
|
|
return AccountID{value: uuid.New()}
|
|
}
|
|
|
|
func (id AccountID) String() string {
|
|
return id.value.String()
|
|
}
|
|
|
|
func (id AccountID) Equals(other AccountID) bool {
|
|
return id.value == other.value
|
|
}
|
|
|
|
// services/session-coordinator/domain/value_objects/session_status.go
|
|
type SessionStatus string
|
|
|
|
const (
|
|
SessionStatusCreated SessionStatus = "created"
|
|
SessionStatusWaiting SessionStatus = "waiting"
|
|
SessionStatusInProgress SessionStatus = "in_progress"
|
|
SessionStatusCompleted SessionStatus = "completed"
|
|
SessionStatusFailed SessionStatus = "failed"
|
|
)
|
|
|
|
func (s SessionStatus) CanTransitionTo(target SessionStatus) bool {
|
|
// 状态转换规则
|
|
transitions := map[SessionStatus][]SessionStatus{
|
|
SessionStatusCreated: {SessionStatusWaiting, SessionStatusFailed},
|
|
SessionStatusWaiting: {SessionStatusInProgress, SessionStatusFailed},
|
|
SessionStatusInProgress: {SessionStatusCompleted, SessionStatusFailed},
|
|
}
|
|
for _, allowed := range transitions[s] {
|
|
if allowed == target {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
```
|
|
|
|
#### 2.3.3 聚合 (Aggregate)
|
|
|
|
聚合根管理一组相关实体的一致性边界：
|
|
|
|
```go
|
|
// services/session-coordinator/domain/entities/mpc_session.go
|
|
// MPCSession 是聚合根，管理 Participants
|
|
type MPCSession struct {
|
|
ID uuid.UUID
|
|
Type SessionType
|
|
Status SessionStatus
|
|
ThresholdT int
|
|
ThresholdN int
|
|
Participants []Participant // 子实体
|
|
CreatedAt time.Time
|
|
}
|
|
|
|
// 聚合根负责维护内部一致性
|
|
func (s *MPCSession) AddParticipant(p Participant) error {
|
|
if len(s.Participants) >= s.ThresholdN {
|
|
return ErrSessionFull
|
|
}
|
|
if s.Status != SessionStatusWaiting {
|
|
return ErrInvalidSessionStatus
|
|
}
|
|
s.Participants = append(s.Participants, p)
|
|
return nil
|
|
}
|
|
|
|
func (s *MPCSession) AllParticipantsReady() bool {
|
|
if len(s.Participants) < s.ThresholdN {
|
|
return false
|
|
}
|
|
for _, p := range s.Participants {
|
|
if p.Status != ParticipantStatusReady {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
```
|
|
|
|
#### 2.3.4 仓储接口 (Repository)
|
|
|
|
领域层定义接口，适配器层实现：
|
|
|
|
```go
|
|
// services/account/domain/repositories/account_repository.go
|
|
type AccountRepository interface {
|
|
Save(ctx context.Context, account *entities.Account) error
|
|
FindByID(ctx context.Context, id value_objects.AccountID) (*entities.Account, error)
|
|
FindByUsername(ctx context.Context, username string) (*entities.Account, error)
|
|
FindByEmail(ctx context.Context, email string) (*entities.Account, error)
|
|
Update(ctx context.Context, account *entities.Account) error
|
|
Delete(ctx context.Context, id value_objects.AccountID) error
|
|
}
|
|
```
|
|
|
|
#### 2.3.5 领域服务 (Domain Service)
|
|
|
|
跨实体的业务逻辑：
|
|
|
|
```go
|
|
// services/session-coordinator/domain/services/session_coordinator.go
|
|
type SessionCoordinatorService struct {
|
|
sessionRepo repositories.SessionRepository
|
|
}
|
|
|
|
func (s *SessionCoordinatorService) ValidateThreshold(t, n int) error {
|
|
if t < 1 || t > n {
|
|
return ErrInvalidThreshold
|
|
}
|
|
if n < 2 {
|
|
return ErrInvalidPartyCount
|
|
}
|
|
return nil
|
|
}
|
|
```
|
|
|
|
### 2.4 六边形架构端口与适配器
|
|
|
|
#### 2.4.1 入站端口 (Input Port)
|
|
|
|
定义用例接口：
|
|
|
|
```go
|
|
// services/account/application/ports/input_ports.go
|
|
type CreateAccountInput struct {
|
|
Username string
|
|
Email string
|
|
PublicKey []byte
|
|
ThresholdN int
|
|
ThresholdT int
|
|
}
|
|
|
|
type CreateAccountOutput struct {
|
|
Account *entities.Account
|
|
}
|
|
|
|
// 用例接口
|
|
type CreateAccountPort interface {
|
|
Execute(ctx context.Context, input CreateAccountInput) (*CreateAccountOutput, error)
|
|
}
|
|
```
|
|
|
|
#### 2.4.2 出站端口 (Output Port)
|
|
|
|
定义基础设施接口：
|
|
|
|
```go
|
|
// services/session-coordinator/application/ports/output/session_storage_port.go
|
|
type SessionStoragePort interface {
|
|
Save(ctx context.Context, session *entities.MPCSession) error
|
|
FindByID(ctx context.Context, id uuid.UUID) (*entities.MPCSession, error)
|
|
Update(ctx context.Context, session *entities.MPCSession) error
|
|
}
|
|
|
|
// services/session-coordinator/application/ports/output/message_broker_port.go
|
|
type MessageBrokerPort interface {
|
|
PublishSessionEvent(ctx context.Context, event SessionEvent) error
|
|
PublishPartyNotification(ctx context.Context, partyID string, msg []byte) error
|
|
}
|
|
```
|
|
|
|
#### 2.4.3 用例实现 (Use Case)
|
|
|
|
编排业务流程：
|
|
|
|
```go
|
|
// services/account/application/use_cases/create_account.go
|
|
type CreateAccountUseCase struct {
|
|
accountRepo repositories.AccountRepository
|
|
eventPub ports.EventPublisherPort
|
|
}
|
|
|
|
func (uc *CreateAccountUseCase) Execute(
|
|
ctx context.Context,
|
|
input ports.CreateAccountInput,
|
|
) (*ports.CreateAccountOutput, error) {
|
|
// 1. 创建领域实体
|
|
account := entities.NewAccount(
|
|
input.Username,
|
|
input.Email,
|
|
input.PublicKey,
|
|
input.ThresholdN,
|
|
input.ThresholdT,
|
|
)
|
|
|
|
// 2. 验证业务规则
|
|
if err := account.Validate(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// 3. 持久化
|
|
if err := uc.accountRepo.Save(ctx, account); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// 4. 发布领域事件
|
|
uc.eventPub.Publish(ctx, events.AccountCreated{AccountID: account.ID})
|
|
|
|
return &ports.CreateAccountOutput{Account: account}, nil
|
|
}
|
|
```
|
|
|
|
#### 2.4.4 入站适配器 (Input Adapter)
|
|
|
|
HTTP/gRPC 处理器：
|
|
|
|
```go
|
|
// services/account/adapters/input/http/account_handler.go
|
|
type AccountHandler struct {
|
|
createAccountUC ports.CreateAccountPort
|
|
loginUC ports.LoginPort
|
|
}
|
|
|
|
func (h *AccountHandler) CreateAccount(c *gin.Context) {
|
|
var req CreateAccountRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(400, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
output, err := h.createAccountUC.Execute(c.Request.Context(), ports.CreateAccountInput{
|
|
Username: req.Username,
|
|
Email: req.Email,
|
|
PublicKey: req.PublicKey,
|
|
ThresholdN: req.ThresholdN,
|
|
ThresholdT: req.ThresholdT,
|
|
})
|
|
if err != nil {
|
|
c.JSON(500, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(201, output)
|
|
}
|
|
```
|
|
|
|
#### 2.4.5 出站适配器 (Output Adapter)
|
|
|
|
数据库/缓存实现：
|
|
|
|
```go
|
|
// services/account/adapters/output/postgres/account_repo.go
|
|
type PostgresAccountRepository struct {
|
|
db *sql.DB
|
|
}
|
|
|
|
func (r *PostgresAccountRepository) Save(ctx context.Context, account *entities.Account) error {
|
|
query := `INSERT INTO accounts (id, username, email, public_key, status, threshold_n, threshold_t, created_at)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`
|
|
_, err := r.db.ExecContext(ctx, query,
|
|
account.ID.String(),
|
|
account.Username,
|
|
account.Email,
|
|
account.PublicKey,
|
|
account.Status,
|
|
account.ThresholdN,
|
|
account.ThresholdT,
|
|
account.CreatedAt,
|
|
)
|
|
return err
|
|
}
|
|
|
|
func (r *PostgresAccountRepository) FindByID(ctx context.Context, id value_objects.AccountID) (*entities.Account, error) {
|
|
query := `SELECT id, username, email, public_key, status, threshold_n, threshold_t, created_at, updated_at
|
|
FROM accounts WHERE id = $1`
|
|
row := r.db.QueryRowContext(ctx, query, id.String())
|
|
// ... scan and return
|
|
}
|
|
```
|
|
|
|
### 2.5 依赖注入 (Dependency Injection)
|
|
|
|
在 main.go 中组装依赖：
|
|
|
|
```go
|
|
// services/account/cmd/server/main.go
|
|
func main() {
|
|
// 基础设施
|
|
db := connectDatabase()
|
|
redisClient := connectRedis()
|
|
rabbitConn := connectRabbitMQ()
|
|
|
|
// 出站适配器 (实现端口)
|
|
accountRepo := postgres.NewAccountRepository(db)
|
|
cacheAdapter := redis.NewCacheAdapter(redisClient)
|
|
eventPublisher := rabbitmq.NewEventPublisher(rabbitConn)
|
|
|
|
// 用例 (注入依赖)
|
|
createAccountUC := use_cases.NewCreateAccountUseCase(accountRepo, eventPublisher)
|
|
loginUC := use_cases.NewLoginUseCase(accountRepo, cacheAdapter)
|
|
|
|
// 入站适配器 (使用用例)
|
|
handler := http.NewAccountHandler(createAccountUC, loginUC)
|
|
|
|
// 启动服务器
|
|
router := gin.Default()
|
|
handler.RegisterRoutes(router)
|
|
router.Run(":8080")
|
|
}
|
|
```
|
|
|
|
### 2.6 DDD 战术模式总览
|
|
|
|
| DDD 概念 | 本系统实现 | 位置 |
|
|
|---------|-----------|------|
|
|
| **Entity** | Account, MPCSession, Participant | `domain/entities/` |
|
|
| **Value Object** | AccountID, SessionStatus, Threshold | `domain/value_objects/` |
|
|
| **Aggregate** | Account (含 AccountShare), MPCSession (含 Participant) | `domain/entities/` |
|
|
| **Repository** | AccountRepository, SessionRepository (接口) | `domain/repositories/` |
|
|
| **Domain Service** | SessionCoordinatorService, AccountService | `domain/services/` |
|
|
| **Application Service** | CreateAccountUseCase, JoinSessionUseCase | `application/use_cases/` |
|
|
| **Input Port** | CreateAccountPort, LoginPort | `application/ports/input/` |
|
|
| **Output Port** | SessionStoragePort, MessageBrokerPort | `application/ports/output/` |
|
|
| **Input Adapter** | AccountHandler (HTTP), SessionGrpcHandler | `adapters/input/` |
|
|
| **Output Adapter** | PostgresRepo, RedisCache, RabbitMQPublisher | `adapters/output/` |
|
|
|
|
## 3. 系统部署架构
|
|
|
|
### 3.1 整体架构图
|
|
|
|
```
|
|
┌─────────────────────────────────────────────────────────────────────┐
|
|
│ Client Layer │
|
|
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
|
|
│ │ iOS App │ │ Android App │ │ Web Client │ │
|
|
│ │ (MPC SDK) │ │ (MPC SDK) │ │ │ │
|
|
│ └──────┬───────┘ └──────┬───────┘ └──────┬───────┘ │
|
|
└─────────┼─────────────────┼─────────────────┼───────────────────────┘
|
|
│ │ │
|
|
▼ ▼ ▼
|
|
┌─────────────────────────────────────────────────────────────────────┐
|
|
│ API Gateway (HTTP/gRPC) │
|
|
└─────────────────────────────┬───────────────────────────────────────┘
|
|
│
|
|
┌───────────────────┼───────────────────┐
|
|
▼ ▼ ▼
|
|
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
|
|
│ Account │ │ Session │ │ Message │
|
|
│ Service │ │ Coordinator │ │ Router │
|
|
│ (用户/账户管理) │ │ (会话协调) │ │ (消息路由) │
|
|
│ │ │ │ │ │
|
|
│ Port: 50054 │ │ Port: 50051 │ │ Port: 50052 │
|
|
│ HTTP: 8083 │ │ HTTP: 8080 │ │ HTTP: 8081 │
|
|
└────────┬────────┘ └────────┬────────┘ └────────┬────────┘
|
|
│ │ │
|
|
│ ▼ │
|
|
│ ┌─────────────────┐ │
|
|
│ │ Server Party │ │
|
|
│ │ Service x N │◄──────────┘
|
|
│ │ (MPC 计算节点) │
|
|
│ │ │
|
|
│ │ Party 1: 50053 │
|
|
│ │ Party 2: 50055 │
|
|
│ │ Party 3: 50056 │
|
|
│ └────────┬────────┘
|
|
│ │
|
|
▼ ▼
|
|
┌─────────────────────────────────────────────────────────────────────┐
|
|
│ Data Layer │
|
|
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
|
|
│ │ PostgreSQL │ │ Redis │ │ RabbitMQ │ │
|
|
│ │ (持久化) │ │ (缓存/会话) │ │ (消息队列) │ │
|
|
│ └──────────────┘ └──────────────┘ └──────────────┘ │
|
|
└─────────────────────────────────────────────────────────────────────┘
|
|
```
|
|
|
|
### 3.2 服务职责
|
|
|
|
#### 3.2.1 Session Coordinator (会话协调器)
|
|
- 创建和管理 MPC 会话
|
|
- 协调参与方加入会话
|
|
- 跟踪会话状态和进度
|
|
- 管理参与方就绪状态
|
|
|
|
#### 3.2.2 Message Router (消息路由器)
|
|
- 路由 TSS 协议消息
|
|
- 支持点对点和广播消息
|
|
- 消息缓存和重传
|
|
- WebSocket 实时通信
|
|
|
|
#### 3.2.3 Server Party (服务端参与方)
|
|
- 作为 MPC 协议的服务端参与方
|
|
- 执行 DKG 和签名协议
|
|
- 安全存储加密的密钥分片
|
|
- 支持多实例部署
|
|
|
|
#### 3.2.4 Account Service (账户服务)
|
|
- 用户注册和认证
|
|
- 账户管理
|
|
- MPC 会话入口 API
|
|
- 账户恢复流程
|
|
|
|
## 4. 核心流程
|
|
|
|
### 4.1 密钥生成流程 (Keygen)
|
|
|
|
```
|
|
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
|
|
│ Client │ │Coordinator│ │ Router │ │ Parties │
|
|
└────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘
|
|
│ │ │ │
|
|
│ CreateSession │ │ │
|
|
│──────────────>│ │ │
|
|
│ │ │ │
|
|
│ SessionID + │ │ │
|
|
│ JoinTokens │ │ │
|
|
│<──────────────│ │ │
|
|
│ │ │ │
|
|
│ JoinSession (各参与方) │
|
|
│──────────────────────────────────────────────>│
|
|
│ │ │ │
|
|
│ MarkReady (各参与方) │
|
|
│──────────────────────────────────────────────>│
|
|
│ │ │ │
|
|
│ StartSession │ │
|
|
│──────────────>│ │ │
|
|
│ │ Notify Start │ │
|
|
│ │──────────────────────────────>│
|
|
│ │ │ │
|
|
│ │ TSS Messages (多轮) │
|
|
│ │ │<─────────────>│
|
|
│ │ │ │
|
|
│ │ ReportCompletion │
|
|
│ │<──────────────────────────────│
|
|
│ │ │ │
|
|
│ Session Completed │ │
|
|
│<──────────────│ │ │
|
|
│ │ │ │
|
|
```
|
|
|
|
### 4.2 签名流程 (Signing)
|
|
|
|
```
|
|
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
|
|
│ Client │ │Coordinator│ │ Router │ │ Parties │
|
|
└────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘
|
|
│ │ │ │
|
|
│ CreateSignSession │ │
|
|
│ (messageHash) │ │ │
|
|
│──────────────>│ │ │
|
|
│ │ │ │
|
|
│ SessionID │ │ │
|
|
│<──────────────│ │ │
|
|
│ │ │ │
|
|
│ JoinSession (t+1 参与方) │ │
|
|
│──────────────────────────────────────────────>│
|
|
│ │ │ │
|
|
│ StartSession │ │
|
|
│──────────────>│ │ │
|
|
│ │ │ │
|
|
│ │ TSS Messages (多轮) │
|
|
│ │ │<─────────────>│
|
|
│ │ │ │
|
|
│ │ Signature │ │
|
|
│ │<──────────────────────────────│
|
|
│ │ │ │
|
|
│ Signature (R, S, V) │ │
|
|
│<──────────────│ │ │
|
|
│ │ │ │
|
|
```
|
|
|
|
## 5. 数据模型
|
|
|
|
### 5.1 Session (会话)
|
|
|
|
```go
|
|
type Session struct {
|
|
ID uuid.UUID // 会话唯一标识
|
|
Type SessionType // keygen | sign
|
|
Status SessionStatus // created | waiting | in_progress | completed | failed
|
|
ThresholdT int // 签名阈值 (t+1 签名者)
|
|
ThresholdN int // 总参与方数
|
|
MessageHash []byte // 待签名消息哈希 (签名会话)
|
|
Participants []Participant // 参与方列表
|
|
CreatedAt time.Time
|
|
ExpiresAt time.Time
|
|
}
|
|
```
|
|
|
|
### 5.2 Participant (参与方)
|
|
|
|
```go
|
|
type Participant struct {
|
|
PartyID string // 参与方标识
|
|
PartyIndex int // 协议中的索引
|
|
DeviceInfo DeviceInfo // 设备信息
|
|
Status ParticipantStatus // joined | ready | computing | completed
|
|
JoinToken string // 加入令牌
|
|
}
|
|
```
|
|
|
|
### 5.3 KeyShare (密钥分片)
|
|
|
|
```go
|
|
type KeyShare struct {
|
|
ID uuid.UUID
|
|
AccountID uuid.UUID
|
|
PartyID string
|
|
EncryptedShareData []byte // AES-GCM 加密的分片数据
|
|
PublicKey []byte // 组公钥
|
|
CreatedAt time.Time
|
|
}
|
|
```
|
|
|
|
## 6. 安全设计
|
|
|
|
### 6.1 密钥安全
|
|
|
|
- **密钥分片存储**: 使用 AES-256-GCM 加密存储
|
|
- **主密钥管理**: 从环境变量或 KMS 加载
|
|
- **无单点故障**: 任意 t 个节点被攻破不影响安全性
|
|
|
|
### 6.2 通信安全
|
|
|
|
- **TLS 加密**: 所有 gRPC/HTTP 通信使用 TLS
|
|
- **消息认证**: TSS 消息包含参与方签名
|
|
- **会话令牌**: 使用 UUID v4 生成一次性令牌
|
|
|
|
### 6.3 安全属性
|
|
|
|
| 属性 | 描述 |
|
|
|------|------|
|
|
| 门限安全 | 需要至少 t+1 方参与才能签名 |
|
|
| 密钥不可恢复 | 少于 t+1 个分片无法恢复私钥 |
|
|
| 前向安全 | 会话密钥独立，历史泄露不影响未来 |
|
|
| 抗合谋 | t 个恶意方无法伪造签名 |
|
|
|
|
## 7. 部署架构
|
|
|
|
### 7.1 最小部署 (2-of-3)
|
|
|
|
```
|
|
┌─────────────────────────────────────────────────────────┐
|
|
│ Server 1 (Coordinator) │
|
|
│ ┌─────────────────┐ ┌─────────────────┐ │
|
|
│ │ Session Coord. │ │ Message Router │ │
|
|
│ │ Port: 50051 │ │ Port: 50052 │ │
|
|
│ └─────────────────┘ └─────────────────┘ │
|
|
│ ┌─────────────────┐ ┌─────────────────┐ │
|
|
│ │ Account Service │ │ PostgreSQL │ │
|
|
│ │ Port: 50054 │ │ Redis/RabbitMQ │ │
|
|
│ └─────────────────┘ └─────────────────┘ │
|
|
└─────────────────────────────────────────────────────────┘
|
|
|
|
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
|
|
│ Server Party 1 │ │ Server Party 2 │ │ Server Party 3 │
|
|
│ Port: 50053 │ │ Port: 50055 │ │ Port: 50056 │
|
|
└──────────────────┘ └──────────────────┘ └──────────────────┘
|
|
```
|
|
|
|
### 7.2 生产环境部署
|
|
|
|
- **高可用**: 每个服务至少 2 副本
|
|
- **负载均衡**: Nginx/Traefik 反向代理
|
|
- **服务发现**: Consul 集群
|
|
- **监控**: Prometheus + Grafana
|
|
|
|
## 8. 目录结构
|
|
|
|
```
|
|
mpc-system/
|
|
├── api/ # API 定义
|
|
│ ├── grpc/ # gRPC 生成代码
|
|
│ └── proto/ # Protobuf 定义
|
|
├── docs/ # 文档
|
|
├── migrations/ # 数据库迁移
|
|
├── pkg/ # 公共包
|
|
│ ├── crypto/ # 加密工具
|
|
│ └── tss/ # TSS 封装
|
|
├── services/ # 微服务
|
|
│ ├── account/ # 账户服务
|
|
│ ├── message-router/ # 消息路由
|
|
│ ├── server-party/ # 服务端参与方
|
|
│ └── session-coordinator/ # 会话协调
|
|
├── tests/ # 测试
|
|
│ ├── e2e/ # 端到端测试
|
|
│ ├── integration/ # 集成测试
|
|
│ └── unit/ # 单元测试
|
|
├── docker-compose.yml # Docker 编排
|
|
├── Makefile # 构建脚本
|
|
└── go.mod # Go 模块
|
|
```
|