go-jose库：Golang中的JWT/JWS/JWE完整实现

go-jose是一个功能强大的Golang库，实现了完整的JWT(JSON Web Token)、JWS(JSON Web Signature)和JWE(JSON Web Encryption)规范。它提供了安全的加密、签名和验证功能，是构建现代认证系统的理想选择。

安装

go get github.com/go-jose/go-jose/v3

基本使用

1. 创建和验证JWT

package main

import (
	"fmt"
	"time"

	"github.com/go-jose/go-jose/v3"
	"github.com/go-jose/go-jose/v3/jwt"
)

func main() {
	// 创建签名密钥
	key := []byte("secret-key-123456") // 生产环境请使用更强的密钥

	// 创建签名器
	signer, err := jose.NewSigner(jose.SigningKey{Algorithm: jose.HS256, Key: key}, nil)
	if err != nil {
		panic(err)
	}

	// 创建JWT声明
	claims := jwt.Claims{
		Subject:   "1234567890",
		Issuer:    "my-auth-service",
		Expiry:    jwt.NewNumericDate(time.Now().Add(24 * time.Hour)),
		NotBefore: jwt.NewNumericDate(time.Now()),
		IssuedAt:  jwt.NewNumericDate(time.Now()),
		Audience:  jwt.Audience{"api-service"},
	}

	// 添加自定义声明
	privateClaims := struct {
		UserID string `json:"user_id"`
		Email  string `json:"email"`
	}{
		UserID: "u123",
		Email:  "user@example.com",
	}

	// 签名生成JWT
	token, err := jwt.Signed(signer).Claims(claims).Claims(privateClaims).CompactSerialize()
	if err != nil {
		panic(err)
	}

	fmt.Println("Generated JWT:", token)

	// 验证JWT
	parsed, err := jwt.ParseSigned(token)
	if err != nil {
		panic(err)
	}

	// 验证声明
	out := jwt.Claims{}
	custom := struct {
		UserID string `json:"user_id"`
	}{}
	if err := parsed.Claims(key, &out, &custom); err != nil {
		panic(err)
	}

	// 验证过期时间等
	if err := out.Validate(jwt.Expected{
		Issuer: "my-auth-service",
		Time:   time.Now(),
	}); err != nil {
		panic(err)
	}

	fmt.Printf("Verified claims: %+v\n", out)
	fmt.Printf("Custom claims: %+v\n", custom)
}

2. 使用JWE加密数据

package main

import (
	"fmt"

	"github.com/go-jose/go-jose/v3"
)

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

	// 创建加密器
	encrypter, err := jose.NewEncrypter(
		jose.A256GCM,
		jose.Recipient{Algorithm: jose.RSA_OAEP, Key: &privateKey.PublicKey},
		(&jose.EncrypterOptions{}).WithType("JWT").WithContentType("JWT"),
	)
	if err != nil {
		panic(err)
	}

	// 加密数据
	payload := []byte("secret message")
	jwe, err := encrypter.Encrypt(payload)
	if err != nil {
		panic(err)
	}

	// 序列化为紧凑格式
	serialized, err := jwe.CompactSerialize()
	if err != nil {
		panic(err)
	}

	fmt.Println("JWE:", serialized)

	// 解密
	parsed, err := jose.ParseEncrypted(serialized)
	if err != nil {
		panic(err)
	}

	decrypted, err := parsed.Decrypt(privateKey)
	if err != nil {
		panic(err)
	}

	fmt.Println("Decrypted:", string(decrypted))
}

3. 高级JWS使用（多签名）

package main

import (
	"crypto/ecdsa"
	"crypto/elliptic"
	"crypto/rand"
	"fmt"

	"github.com/go-jose/go-jose/v3"
)

func main() {
	// 创建多个签名密钥
	hmacKey := []byte("secret-key-123456")
	ecdsaKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
	if err != nil {
		panic(err)
	}

	// 创建多个签名器
	signer1, err := jose.NewSigner(jose.SigningKey{Algorithm: jose.HS256, Key: hmacKey}, nil)
	if err != nil {
		panic(err)
	}

	signer2, err := jose.NewSigner(jose.SigningKey{Algorithm: jose.ES256, Key: ecdsaKey}, nil)
	if err != nil {
		panic(err)
	}

	// 创建多重签名
	multiSig := jose.MultiSigner{signer1, signer2}
	payload := []byte("multi-signed message")

	// 签名
	signed, err := multiSig.Sign(payload)
	if err != nil {
		panic(err)
	}

	// 序列化
	serialized, err := signed.CompactSerialize()
	if err != nil {
		panic(err)
	}

	fmt.Println("Multi-signed JWS:", serialized)

	// 验证
	parsed, err := jose.ParseSigned(serialized)
	if err != nil {
		panic(err)
	}

	// 验证其中一个签名即可
	_, err = parsed.Verify(hmacKey)
	if err != nil {
		_, err = parsed.Verify(&ecdsaKey.PublicKey)
		if err != nil {
			panic(err)
		}
	}

	fmt.Println("Signature verified successfully")
}

安全最佳实践

1. 密钥管理：

   • 永远不要将密钥硬编码在代码中
   • 使用环境变量或密钥管理系统
   • 定期轮换密钥

2. 算法选择：

   • 签名：推荐使用ES256 (ECDSA P-256) 或 RS256 (RSA 2048+)
   • 加密：推荐使用RSA-OAEP或ECDH-ES+A256KW

3. 令牌验证：

   • 总是验证令牌的签名
   • 检查过期时间(exp)
   • 验证发行者(iss)和受众(aud)
   • 检查令牌是否已撤销

4. 令牌生命周期：

   • 设置合理的过期时间
   • 考虑使用刷新令牌机制
   • 实现令牌撤销机制

go-jose库提供了企业级的安全功能实现，可以满足大多数现代认证和加密需求。在实际应用中，建议结合具体的业务场景和安全要求进行适当的配置和扩展。