Go Keychain

go钥匙扣

](https://golang.org) ](https://github.com/jeremyhahn/go-keychain/releases)     

用于本地、混合和/或云的安全加密密钥和证书管理解决方案。

功能一览

• 10个生产就绪后端：PKCS#8、AES、PKCS#11、智能卡HSM、TPM2、YubiKey、AWS KMS、GCP KMS、Azure密钥库、HashiCorp密钥库
• 完成密钥管理：生成、存储、检索、旋转和删除密钥（RSA、ECDSA、Ed25519、AES）
• 对称加密：AES-GCM（128/192/256位），所有后端均支持AEAD安全
• 证书操作：完整的X.509证书生命周期，包括链和CRL支持
• 加密货币操作：使用标准Go接口进行签名、验证、加密、解密
• 线程安全：通过适当的同步，可以安全地进行并发操作
• 测试良好：92.5%的单元测试覆盖率，151个通过集成测试
• 可插拔架构：易于添加自定义后端和存储实施
• 统一服务API：抽象后端复杂性的简单API

概述

go钥匙扣 提供了一个统一的接口，用于跨多种后端类型管理加密密钥和证书，从简单的基于文件的存储到硬件安全模块和云KMS服务。

核心焦点

• 钥匙：生成、存储、检索、旋转加密密钥
• 证书：管理X.509证书、链和CRL
• 后端：可插拔存储（PKCS#8、PKCS#11、TPM2、云KMS）
• 标准：PKCS#8、PEM、X.509、CRL格式

设计原则

• 整洁架构：明确的关注点分离，基于界面的设计
• 可插拔后端：易于添加新的存储类型
• 统一服务API：用于所有后端的单个API-没有泄漏的抽象
• 线程安全：对并发操作安全
• 测试良好：92.5%的单元测试覆盖率，151个通过集成测试
• 生产准备就绪：v0.2.0-alpha，带有10个完全工作的后端
• 重点范围：只有密钥和证书-没有服务器/事件/秘密

______________________________________________________________________

特性

密钥管理

• 非对称密钥：RSA（2048/3072/4096）、ECDSA（P-256/P-384/P-521）、Ed25519
• 对称密钥：带认证加密的AES-GCM（128/192/256位）
• 存储：使用可选密码加密进行安全存储
• 运营：签名、验证、加密、解密（非对称和对称）
• 旋转：安全密钥旋转，删除旧密钥
• 多个后端：PKCS#8、AES、PKCS#11（HSM）、TPM2、AWS/GCP/Azure知识管理系统、保险库

证书管理

• CRUD操作：存储、检索、删除证书
• 证书链：构建和验证证书链
• CRL支持：证书吊销列表管理
• 验证：具有可配置选项的证书验证
• 撤销检查：检查证书是否被吊销
• 硬件存储：本机PKCS#11 HSM和TPM2 NV RAM证书存储
• 混合模式：硬件和外部存储之间的自动故障切换

加密操作

• 签署：所有具有多种哈希算法的非对称密钥类型
• 验证：多算法签名验证
• 非对称加密：使用PKCS1v15、PSS和OAEP填充的RSA加密
• 对称加密：带附加数据的AES-GCM认证加密（AEAD）
• TLS集成：轻松配置TLS证书
• 标准接口：实施 crypto.Signer 和 crypto.Decrypter

后端支持

真正的后端支持 所有这三个 操作类型：不对称、对称和密封。

便利图书馆

构建块和专用加密库：

______________________________________________________________________

客户端接口

go钥匙链提供 5个客户端接口 用于访问密钥和证书操作：

所有接口都公开密钥和证书的完整KeyStore API。看 docs/api-parity.md 了解详细的方法覆盖范围。

接口示例

CLI（命令行）：

# Key Management
keychain key generate --name my-key --type rsa --size 2048
keychain key generate --name signing-key --type ecdsa --curve P-256
keychain key generate --name ed-key --type ed25519
keychain key list
keychain key get my-key
keychain key delete my-key
keychain key rotate my-key

# Certificate Management
keychain cert list
keychain cert get my-key
keychain cert delete my-key

# Admin Management (requires FIDO2 security key)
keychain admin status
keychain admin create admin@example.com --display-name "Admin"
keychain admin list
keychain admin get admin@example.com
keychain admin disable admin@example.com
keychain admin enable admin@example.com

# FIDO2 Operations
keychain fido2 list        # List connected security keys
keychain fido2 info        # Show device information

# Backend Information
keychain backends          # List available backends

REST API：

# Generate a key
curl -X POST http://localhost:8443/api/v1/keys \
  -H "Content-Type: application/json" \
  -d '{"key_id": "my-key", "key_type": "rsa", "key_size": 2048}'

# List keys
curl http://localhost:8443/api/v1/keys

# Get a key's public info
curl http://localhost:8443/api/v1/keys/my-key

# Sign data
curl -X POST http://localhost:8443/api/v1/keys/my-key/sign \
  -H "Content-Type: application/json" \
  -d '{"data": "SGVsbG8gV29ybGQ=", "hash": "sha256"}'

# Health check
curl http://localhost:8443/api/v1/health

gRPC：

import pb "github.com/jeremyhahn/go-keychain/api/proto/keychainv1"

conn, _ := grpc.Dial("localhost:9443", grpc.WithInsecure())
client := pb.NewKeychainServiceClient(conn)

// Generate key
resp, _ := client.GenerateKey(ctx, &pb.GenerateKeyRequest{
    KeyId:   "my-key",
    KeyType: pb.KeyType_KEY_TYPE_RSA,
    KeySize: 2048,
})

// List keys
keys, _ := client.ListKeys(ctx, &pb.ListKeysRequest{})

MCP（模型上下文协议-用于AI助手）：

{"jsonrpc": "2.0", "method": "keychain.generateKey",
 "params": {"key_id": "my-key", "key_type": "rsa", "key_size": 2048}, "id": 1}

{"jsonrpc": "2.0", "method": "keychain.listKeys", "params": {}, "id": 2}

{"jsonrpc": "2.0", "method": "keychain.sign",
 "params": {"key_id": "my-key", "data": "base64data", "hash": "sha256"}, "id": 3}

QUIC（HTTP/3-基于UDP的低延迟）：

# Same REST API over QUIC/HTTP3
curl --http3 https://localhost:8444/api/v1/keys
curl --http3 https://localhost:8444/api/v1/health

______________________________________________________________________

安装

作为图书馆

go get github.com/jeremyhahn/go-keychain

作为服务器

# Build the server and CLI
make build-server build-cli

# Copy binaries to system path
sudo cp bin/keychaind bin/keychain /usr/bin/

看 部署/README.md 用于systemd和OpenRC服务安装。

______________________________________________________________________

服务器快速启动

1.首次设置

在将go钥匙链用作服务之前，您必须使用FIDO2安全密钥创建管理员帐户：

# Check if setup is required
keychain admin status

# Create the first administrator (requires FIDO2 security key)
keychain admin create admin@example.com --display-name "Admin User"
# Touch your security key when prompted...

# Verify the admin was created
keychain admin list

要求：

• 与FIDO2兼容的安全密钥（YubiKey 5、SoloKey、Nitrokey等）
• 安全密钥必须通过USB连接

2.配置服务器

在以下位置创建配置文件 /etc/keychain/config.yaml:

# Server configuration
server:
  host: "0.0.0.0"
  rest_port: 8443
  grpc_port: 9443
  quic_port: 8444

# Default backend
default: pkcs8

# Backend configurations
backends:
  pkcs8:
    enabled: true
    key_dir: /var/lib/keychain/keys

3.启动服务器

# Direct execution
keychaind -config /etc/keychain/config.yaml

# Or via systemd (after installing service files)
sudo systemctl start keychain

4.验证服务器是否正在运行

# REST API health check
curl http://localhost:8443/api/v1/health

# List keys via CLI
keychain key list

# Generate a test key
keychain key generate --name test-key --type rsa --size 2048

______________________________________________________________________

快速入门（库使用）

go-keychain根据您的用例提供了两种API模式：

模式1：直接密钥库（推荐用于库）

使用 keychain.New() 当您需要具有显式生命周期管理的单个密钥库实例时：

package main

import (
    "crypto"
    "crypto/rand"
    "log"

    "github.com/jeremyhahn/go-keychain/pkg/backend/software"
    "github.com/jeremyhahn/go-keychain/pkg/keychain"
    "github.com/jeremyhahn/go-keychain/pkg/storage/file"
    "github.com/jeremyhahn/go-keychain/pkg/types"
)

func main() {
    // 1. Create storage backends
    keyStorage, err := file.New("./keys")
    if err != nil {
        log.Fatal(err)
    }
    certStorage, err := file.New("./certs")
    if err != nil {
        log.Fatal(err)
    }

    // 2. Create the software backend (supports all operations: keys, encryption, sealing)
    backend, err := software.NewBackend(&software.Config{
        KeyStorage: keyStorage,
    })
    if err != nil {
        log.Fatal(err)
    }
    defer backend.Close()

    // 3. Create the KeyStore
    ks, err := keychain.New(&keychain.Config{
        Backend:     backend,
        CertStorage: certStorage,
    })
    if err != nil {
        log.Fatal(err)
    }
    defer ks.Close()

    // 4. Generate a key
    attrs := &types.KeyAttributes{
        CN:        "my-signing-key",
        KeyType:   types.KeyTypeSigning,
        StoreType: types.StoreSoftware,
        RSAAttributes: &types.RSAAttributes{
            KeySize: 2048,
        },
    }

    key, err := ks.GenerateRSA(attrs)
    if err != nil {
        log.Fatal(err)
    }

    // 5. Use the key for signing
    signer, err := ks.Signer(attrs)
    if err != nil {
        log.Fatal(err)
    }

    data := []byte("Hello, World!")
    signature, err := signer.Sign(rand.Reader, data, crypto.SHA256)
    if err != nil {
        log.Fatal(err)
    }

    log.Printf("Generated signature: %x...", signature[:16])
}

模式2：全局服务（建议用于服务器）

使用 keychain.Initialize() 对于需要多个具有全局访问权限的后端的服务器应用程序：

package main

import (
    "crypto"
    "log"

    "github.com/jeremyhahn/go-keychain/pkg/backend/software"
    "github.com/jeremyhahn/go-keychain/pkg/keychain"
    "github.com/jeremyhahn/go-keychain/pkg/storage/file"
    "github.com/jeremyhahn/go-keychain/pkg/types"
)

func main() {
    // 1. Create storage and backend
    keyStorage, _ := file.New("./keys")
    certStorage, _ := file.New("./certs")

    // Software backend supports asymmetric keys, symmetric encryption, and sealing
    softwareBackend, _ := software.NewBackend(&software.Config{KeyStorage: keyStorage})
    softwareKS, _ := keychain.New(&keychain.Config{
        Backend:     softwareBackend,
        CertStorage: certStorage,
    })

    // 2. Initialize the global service
    err := keychain.Initialize(&keychain.ServiceConfig{
        Backends: map[string]keychain.KeyStore{
            "software": softwareKS,
        },
        DefaultBackend: "software",
    })
    if err != nil {
        log.Fatal(err)
    }
    defer keychain.Close()

    // 3. Use global functions - keys are referenced as "backend:keyid" or just "keyid" for default
    attrs := &types.KeyAttributes{
        CN:        "server-key",
        KeyType:   types.KeyTypeSigning,
        StoreType: types.StoreSoftware,
        RSAAttributes: &types.RSAAttributes{KeySize: 2048},
    }

    _, err = keychain.GenerateKey(attrs)
    if err != nil {
        log.Fatal(err)
    }

    // Sign using the global service
    signature, err := keychain.Sign("server-key", []byte("data"), &keychain.SignOptions{
        Hash: crypto.SHA256,
    })
    if err != nil {
        log.Fatal(err)
    }

    log.Printf("Signature: %x...", signature[:16])

    // List available backends
    backends := keychain.Backends()
    log.Printf("Available backends: %v", backends)
}

对称加密示例

package main

import (
    "log"

    "github.com/jeremyhahn/go-keychain/pkg/backend/software"
    "github.com/jeremyhahn/go-keychain/pkg/keychain"
    "github.com/jeremyhahn/go-keychain/pkg/storage/file"
    "github.com/jeremyhahn/go-keychain/pkg/types"
)

func main() {
    // Setup - software backend supports both asymmetric and symmetric operations
    keyStorage, _ := file.New("./keys")
    certStorage, _ := file.New("./certs")
    backend, _ := software.NewBackend(&software.Config{KeyStorage: keyStorage})
    defer backend.Close()

    ks, _ := keychain.New(&keychain.Config{
        Backend:     backend,
        CertStorage: certStorage,
    })
    defer ks.Close()

    // Generate AES-256-GCM key
    attrs := &types.KeyAttributes{
        CN:                 "encryption-key",
        KeyType:            types.KeyTypeEncryption,
        StoreType:          types.StoreSoftware,
        SymmetricAlgorithm: types.SymmetricAES256GCM,
    }

    _, err := ks.GenerateSymmetricKey(attrs)
    if err != nil {
        log.Fatal(err)
    }

    // Encrypt data
    encrypter, err := ks.SymmetricEncrypter(attrs)
    if err != nil {
        log.Fatal(err)
    }

    plaintext := []byte("sensitive data")
    ciphertext, err := encrypter.Encrypt(plaintext, nil)
    if err != nil {
        log.Fatal(err)
    }

    // Decrypt data
    decrypted, err := encrypter.Decrypt(ciphertext, nil)
    if err != nil {
        log.Fatal(err)
    }

    log.Printf("Decrypted: %s", decrypted)
}

有关更多示例，请参阅 示例/ 目录和 docs/usage/geting-started.md.

______________________________________________________________________

钥匙链服务API

这 keychain 包提供了一个简化的服务API，抽象了后端复杂性。初始化后，您可以使用简单的函数调用，而无需直接管理KeyStore实例。

服务功能概述

import "github.com/jeremyhahn/go-keychain/pkg/keychain"

// Initialization
keychain.Initialize(config)     // Initialize with backends
keychain.IsInitialized()        // Check if initialized
keychain.Close()                // Close all backends
keychain.Reset()                // Reset for testing

// Backend Access
keychain.Backend("pkcs8")       // Get specific backend
keychain.DefaultBackend()       // Get default backend
keychain.Backends()             // List all backend names

// Key Operations (use key references like "my-key" or "backend:my-key")
keychain.GenerateKey(attrs)              // Generate key on default backend
keychain.GenerateKeyWithBackend("tpm2", attrs)  // Generate on specific backend
keychain.KeyByID("my-key")               // Get key by ID
keychain.DeleteKey("my-key")             // Delete key
keychain.RotateKey("my-key")             // Rotate key
keychain.ListKeys()                      // List all keys
keychain.ListKeys("pkcs8")               // List keys from specific backend

// Crypto Operations
keychain.Signer("my-key")                // Get crypto.Signer
keychain.Decrypter("my-key")             // Get crypto.Decrypter
keychain.Sign("my-key", data, opts)      // Sign data
keychain.Verify("my-key", data, sig, opts)  // Verify signature

// Symmetric Encryption
keychain.GenerateSymmetricKey("aes", attrs)  // Generate symmetric key
keychain.GetSymmetricKey("my-aes-key")       // Get symmetric key
keychain.Encrypt("my-aes-key", data, opts)   // Encrypt data
keychain.Decrypt("my-aes-key", encrypted, opts)  // Decrypt data

// Certificate Operations
keychain.SaveCertificate("my-key", cert)
keychain.Certificate("my-key")
keychain.DeleteCertificate("my-key")
keychain.ListCertificates()
keychain.SaveCertificateChain("my-key", chain)
keychain.CertificateChain("my-key")
keychain.CertificateExists("my-key")

// TLS Operations
keychain.GetTLSCertificate("my-key")     // Get tls.Certificate

// Sealing Operations (hardware-backed encryption)
keychain.Seal(ctx, data, opts)           // Seal with default backend
keychain.SealWithBackend(ctx, "tpm2", data, opts)
keychain.Unseal(ctx, sealed, opts)       // Unseal data
keychain.CanSeal()                       // Check if sealing supported

// Import/Export Operations
keychain.GetImportParameters(backend, attrs, algorithm)
keychain.WrapKey(backend, keyMaterial, params)
keychain.UnwrapKey(backend, wrapped, params)
keychain.ImportKey(backend, attrs, wrapped)
keychain.ExportKey("my-key", algorithm)
keychain.CopyKey("source:my-key", "dest-backend", attrs)

密钥参考格式

密钥可以以两种格式引用：

• "my-key" -使用默认后端
• "backend:my-key" -使用特定的后端（例如。， "tpm2:signing-key")

完整示例：密钥生成和签名

package main

import (
    "crypto"
    "crypto/x509"
    "log"

    "github.com/jeremyhahn/go-keychain/pkg/backend/software"
    "github.com/jeremyhahn/go-keychain/pkg/keychain"
    "github.com/jeremyhahn/go-keychain/pkg/storage/file"
    "github.com/jeremyhahn/go-keychain/pkg/types"
)

func main() {
    // 1. Setup storage and backend
    keyStorage, _ := file.New("./keys")
    certStorage, _ := file.New("./certs")
    backend, _ := software.NewBackend(&software.Config{KeyStorage: keyStorage})

    ks, _ := keychain.New(&keychain.Config{
        Backend:     backend,
        CertStorage: certStorage,
    })

    // 2. Initialize global service (for server applications)
    err := keychain.Initialize(&keychain.ServiceConfig{
        Backends:       map[string]keychain.KeyStore{"software": ks},
        DefaultBackend: "software",
    })
    if err != nil {
        log.Fatal(err)
    }
    defer keychain.Close()

    // 3. Generate an RSA key
    attrs := &types.KeyAttributes{
        CN:           "my-signing-key",
        KeyType:      types.KeyTypeSigning,
        StoreType:    types.StoreSoftware,
        KeyAlgorithm: x509.RSA,
        RSAAttributes: &types.RSAAttributes{
            KeySize: 2048,
        },
    }

    key, err := keychain.GenerateKey(attrs)
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Generated key: %T", key)

    // 4. Sign some data
    data := []byte("Hello, World!")
    signature, err := keychain.Sign("my-signing-key", data, &keychain.SignOptions{
        Hash: crypto.SHA256,
    })
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Signature: %x", signature[:16])

    // 5. Verify the signature
    err = keychain.Verify("my-signing-key", data, signature, &types.VerifyOpts{
        Hash: crypto.SHA256,
    })
    if err != nil {
        log.Fatal("Verification failed:", err)
    }
    log.Println("Signature verified!")
}

证书管理

// Store a certificate
cert := &x509.Certificate{...}
if err := ks.SaveCert("example.com", cert); err != nil {
    log.Fatal(err)
}

// Retrieve a certificate
cert, err := ks.GetCert("example.com")
if err != nil {
    log.Fatal(err)
}

// Store a certificate chain
chain := []*x509.Certificate{leafCert, intermediateCert, rootCert}
if err := ks.SaveCertChain("example.com", chain); err != nil {
    log.Fatal(err)
}

______________________________________________________________________

建筑

封装结构

go-keychain/
├── pkg/
│   ├── storage/           # Storage interfaces
│   │   ├── file/          # File-based storage
│   │   └── memory/        # In-memory storage
│   │
│   ├── backend/           # Backend interface & types
│   │   ├── pkcs8/         # PKCS#8 file backend
│   │   ├── pkcs11/        # HSM backend
│   │   ├── awskms/        # AWS KMS backend
│   │   ├── gcpkms/        # GCP KMS backend
│   │   ├── azurekv/       # Azure Key Vault backend
│   │   └── vault/         # HashiCorp Vault backend
│   │
│   ├── tpm2/              # TPM2 implementation
│   │
│   ├── encoding/          # PKCS#8 & PEM encoding
│   ├── verification/      # Signature verification
│   ├── signing/           # Enhanced signer
│   ├── opaque/            # OpaqueKey wrapper
│   │
│   ├── keychain/          # Composite KeyStore
│   └── certstore/         # Certificate Store
│
├── examples/              # Usage examples
└── test/
    └── integration/       # Integration test suite (151 tests)

设计模式

┌─────────────┐
│  KeyStore   │  Composite:
│             │  - Backend (keys)
│             │  - CertStorage (certificates)
└──────┬──────┘
       │
       ├──────> Backend Interface
       │        ├── PKCS#8 (file-based)
       │        ├── PKCS#11 (HSM)
       │        ├── TPM2
       │        ├── Cloud KMS (AWS/GCP/Azure)
       |        ├── HashiCorp Vault
       │        └── Custom implementation
       │
       └──────> CertificateStorage Interface
                ├── File storage
                ├── Memory Storage
                └── Custom adapters (interface compatible with go-objstore)

______________________________________________________________________

例子

这 examples/ 目录包含全面的使用示例：

• 基本/ -密钥生成和存储
• 签字/ -签字与验证
• 证书/ -CA创建、证书颁发、链管理
• tls/ -TLS服务器和客户端设置
• 高级/ -按键轮换，并发操作

看 示例/README.md 了解详情。

______________________________________________________________________

安全考虑

密码保护

PKCS#8后端支持密码保护的密钥存储：

attrs.Password = []byte("secure-password")
key, err := ks.GenerateRSA(attrs)

硬件支持密钥

对于生产环境，使用HSM或TPM后端：

// PKCS#11 (HSM)
backend, err := pkcs11.New(&pkcs11.Config{
    Library: "/usr/lib/softhsm/libsofthsm2.so",
    // ...
})

// TPM2
backend, err := tpm2.New(&tpm2.Config{
    Device: "/dev/tpmrm0",
    // ...
})

云知识管理系统

对于云部署：

// AWS KMS
backend, err := awskms.New(&awskms.Config{
    Region: "us-east-1",
    // ...
})

// GCP KMS
backend, err := gcpkms.New(&gcpkms.Config{
    ProjectID: "my-project",
    // ...
})

// Azure Key Vault
backend, err := azurekv.New(&azurekv.Config{
    VaultURL: "https://my-vault.vault.azure.net/",
    // ...
})

// HashiCorp Vault
backend, err := vault.New(&vault.Config{
    Address: "https://vault.example.com:8200",
    // ...
})

______________________________________________________________________

文档

API文档

API完整文档可通过GoDoc获取：

go doc github.com/jeremyhahn/go-keychain/pkg/keychain
go doc github.com/jeremyhahn/go-keychain/pkg/backend
go doc github.com/jeremyhahn/go-keychain/pkg/certstore

详细指南

综合文档可在 docs/ 目录：

• 入门指南 -使用go钥匙扣的分步指南
• 证书管理 -证书存储模式和最佳实践
• 后端指南 -后端特定的配置和使用
• 存储抽象 -存储层架构
• 测试指导 -运行测试和编写新测试
• 构建系统 -构建和部署说明

核心接口

密钥库 -密钥和证书操作的主界面：

type KeyStore interface {
    // Key operations
    GenerateRSA(attrs *backend.KeyAttributes) (crypto.PrivateKey, error)
    GenerateECDSA(attrs *backend.KeyAttributes) (crypto.PrivateKey, error)
    GenerateEd25519(attrs *backend.KeyAttributes) (crypto.PrivateKey, error)
    GetKey(attrs *backend.KeyAttributes) (crypto.PrivateKey, error)
    DeleteKey(attrs *backend.KeyAttributes) error
    RotateKey(attrs *backend.KeyAttributes) (crypto.PrivateKey, error)

    // Certificate operations
    SaveCert(cn string, cert *x509.Certificate) error
    GetCert(cn string) (*x509.Certificate, error)
    DeleteCert(cn string) error

    // Crypto operations
    Signer(attrs *backend.KeyAttributes) (crypto.Signer, error)
    Decrypter(attrs *backend.KeyAttributes) (crypto.Decrypter, error)
}

后端 -密钥存储后端接口：

type Backend interface {
    Type() StoreType
    Capabilities() Capabilities
    GenerateKey(attrs *KeyAttributes) (crypto.PrivateKey, error)
    GetKey(attrs *KeyAttributes) (crypto.PrivateKey, error)
    DeleteKey(attrs *KeyAttributes) error
    Signer(attrs *KeyAttributes) (crypto.Signer, error)
    Decrypter(attrs *KeyAttributes) (crypto.Decrypter, error)
    Close() error
}

______________________________________________________________________

贡献

此库侧重于加密密钥和证书管理。此范围之外的功能（如事件系统、机密管理或服务器基础设施）应在消费应用程序中实现。

开发设置

# Clone the repository
git clone https://github.com/jeremyhahn/go-keychain
cd go-keychain

# Install dependencies
go mod download

# Run unit tests
go test ./pkg/... -cover

# Run integration tests
go test -tags=integration ./test/integration/... -v

______________________________________________________________________

许可证


go钥匙扣可在a 双重许可模式:

选项1:GNU Affero通用公共许可证v3.0（AGPL-3.0）

go keychain的开源版本是根据 AGPL-3.0.

这是什么意思？

• ✓ 免费使用、修改和分发
• ✓ 非常适合开源项目
• ⚠️ 如果你修改并部署为网络服务（SaaS），你 必须 公开你的源代码
• ⚠️ 衍生作品也必须根据AGPL-3.0获得许可

AGPL-3.0要求，如果您修改此软件并将其作为网络上的服务提供（包括SaaS部署），则必须在相同的许可证下提供修改后的源代码。

选项2：商业许可

如果您希望在没有AGPL-3.0源代码披露要求的专有软件中使用go密钥链，可以从以下网址获得商业许可证 自动化事物有限责任公司.

商业许可证的好处：

• ✓ 在闭源应用程序中使用
• ✓ 无源代码披露要求
• ✓ 修改并保持更改私有
• ✓ 专业支持和SLA选项
• ✓ 可定制开发
• ✓ 法律保护和赔偿

商业许可联系人：

关于定价和商业许可咨询：

📧 licensing@automatethethings.com

🌐 https://automatethethings.com

看 许可证商业.md 了解更多详情。

选择正确的许可证

______________________________________________________________________

版权所有©2025自动化事物有限责任公司。保留所有权利。

支持

请考虑支持这个项目，以取得持续的成功和可持续性。我是一名充满激情的开源贡献者，以创造免费、安全、可扩展、健壮、企业级、分布式系统和云原生解决方案为职业。

我也有国际咨询的机会。请让我知道我如何帮助您或您的组织实现所需的安全态势和技术目标。

https://github.com/sponsors/jeremyhahn

https://www.linkedin.com/in/jeremyhahn