最近看了一个名为go-auth的库，它将JWT作为HTTP cookie对用户进行验证，但这个例子中缺少了对JWT的保护，由此进行了一些针对JWX的研究。
下面描述来自golang-jwt的官方描述：
JWT是一个签名的JSON对象，通常用作Oauth2的Bearer token，JWT包括三个用.分割的部分：前两部分为使用base64url编码的JSON对象，最后一部分是签名。第一部分称为header，包含用于验证最后一部分签名所需的信息，如使用的签名方式和使用的密钥等，中间的部分是程序最关心的部分，称为Claim， RFC 7519定义了相关的字段，当然也可以添加自己的字段。
一个token是一个签名的json对象，涉及两方面的内容：
需要注意的是，JWT并不支持加密，因此任何人都能读取token 的内容。如果需要加密数据，可以使用配套的规范--JWE，可以参考这两个库：lestrrat-go/jwx和golang-jwt/jwe。
签名方法有很多种，在使用前可能需要花时间挑选合适的签名方法，主要考量点为：对称和非对称。
对称签名方法，如HSA，只需要一个secret即可，这也是最简单的签名方法，可以使用任何[]byte作为有效的secret。对称加密的计算速度也相对快一些。当token的生产者和消费者都可信的前提下，可以考虑使用对称加密。由于对称加密使用相同的secret进行token的签名和验证，因此不能轻易将密钥分发出去。
非对称签名，如RSA，则使用了不同的密钥进行签名和token验证，因此可以使用私钥生成token，并允许消费者使用公钥进行验证。
这里提一下，OAuth和JWT并不是一回事，一个JWT token只是一个简单的被签名的JSON对象，可以用在所需要的地方，最常见的方式是用在OAuth2认证中。
下面描述了二者是如何交互的：
从上面的官方描述中可以看到JWT其实就是一个字符串，其分为三段：header，主要指定签名方法；claim，用于提供用户身份数据；signature，使用header中指定的签名方法进行签名，签名时主要使用了三个基础数据：
签名密钥：在对称签名(如HMAC)中作为哈希数据的一部分，在非对称签名(如ECDSA)中则作为私钥。在JWT的签名和验证过程中都需要使用到密钥。
JWT的过期时间：JWT有一个过期时间。在用户登陆服务器之后，服务器会给客户端返回JWT，当客户端服务服务端时会将JWT传递给服务端，服务端除了需要验证客户端的签名之外还需要验证该token是否过期，JWT的过期时间数据位于claims中。
claim：主要包含了JWT相关的信息，用户可以扩展自己的claim信息。签名方法会使用这部分信息进行签名。如下是标准的claims，可以看到这部分信息其实与SSL证书中的字段雷同。
type StandardClaims struct {
Audience string `json:"aud,omitempty"`
ExpiresAt int64 `json:"exp,omitempty"`
Id string `json:"jti,omitempty"`
IssuedAt int64 `json:"iat,omitempty"`
Issuer string `json:"iss,omitempty"`
NotBefore int64 `json:"nbf,omitempty"`
Subject string `json:"sub,omitempty"`
}
另外需要注意的是，JWT是使用明文交互的，其中claim中包含了用户的敏感信息，因此需要使用JWE进行加密。
在了解JWT之前可以看下几个重要的术语：
JWS(SignedJWT)：经过签名的jwt，为三段式结构：header、claims、signature
JWA：签名算法，即 header中的alg字段值。
JWE(EncryptedJWT)：用于加密payload，如JWT，主要字段如下：
const (
AgreementPartyUInfoKey = "apu" #(Algorithm) Header Parameter
AgreementPartyVInfoKey = "apv"
AlgorithmKey = "alg" #(Algorithm) Header Parameter
CompressionKey = "zip" #(Compression Algorithm) Header Parameter
ContentEncryptionKey = "enc" #(Encryption Algorithm) Header Parameter
ContentTypeKey = "cty" #(Content Type) Header Parameter
CriticalKey = "crit" #(Critical) Header Parameter
EphemeralPublicKeyKey = "epk"
JWKKey = "jwk" #(JSON Web Key) Header Parameter
JWKSetURLKey = "jku" #(JWK Set URL) Header Parameter
KeyIDKey = "kid" #(Key ID) Header Parameter
TypeKey = "typ" #(Type) Header Parameter
X509CertChainKey = "x5c" #(X.509 Certificate Chain) Header Parameter
X509CertThumbprintKey = "x5t" #(X.509 Certificate SHA-1 Thumbprint) Header Parameter
X509CertThumbprintS256Key = "x5t#S256" #(X.509 Certificate SHA-256 Thumbprint) Header Parameter
X509URLKey = "x5u" #(X.509 URL) Header Parameter
)
JWK：是一个JSON数据结构，用于JWS的签名验证以及JWE的加解密，主要字段如下：
const (
KeyTypeKey = "kty" #(Key Type) Parameter
KeyUsageKey = "use" #(Public Key Use) Parameter
KeyOpsKey = "key_ops" #(Key Operations) Parameter
AlgorithmKey = "alg" #(Algorithm) Parameter
KeyIDKey = "kid" #(Key ID) Parameter
X509URLKey = "x5u" #(X.509 URL) Parameter
X509CertChainKey = "x5c" #(X.509 Certificate Chain) Parameter
X509CertThumbprintKey = "x5t" #(X.509 Certificate SHA-1 Thumbprint) Parameter
X509CertThumbprintS256Key = "x5t#S256" #(X.509 Certificate SHA-256 Thumbprint) Parameter
)
lestrrat-go库中给出了很多例子。在使用该库之前简单看下主要的函数：
jwt.NewBuilder：创建一个表示JWT 的结构体(也可以使用jwt.New创建)：
type stdToken struct {
mu *sync.RWMutex
dc DecodeCtx // per-object context for decoding
options TokenOptionSet // per-object option
audience types.StringList // https://tools.ietf.org/html/rfc7519#section-4.1.3
expiration *types.NumericDate // https://tools.ietf.org/html/rfc7519#section-4.1.4
issuedAt *types.NumericDate // https://tools.ietf.org/html/rfc7519#section-4.1.6
issuer *string // https://tools.ietf.org/html/rfc7519#section-4.1.1
jwtID *string // https://tools.ietf.org/html/rfc7519#section-4.1.7
notBefore *types.NumericDate // https://tools.ietf.org/html/rfc7519#section-4.1.5
subject *string // https://tools.ietf.org/html/rfc7519#section-4.1.2
privateClaims map[string]interface{} //用户自定义的claims
}
jwt.Sign：用于对JWT 进行签名，输入为表示JWT元素的stdToken，输出为[]byte
jwt.Parse：将签名的token解析为stdToken，输入为jwt.Sign的输出。
jws.sign：使用字符串来创建JWS消息，入参为[]byte。与jwt.Sign的不同点在于，前者的入参是stdToken标准结构体，而后者是任意字符串。
jws.parse：对编码的JWS消息进行解码，输出结构如下：
type Message struct {
dc DecodeCtx
payload []byte
signatures []*Signature
b64 bool // true if payload should be base64 encoded
}
jwe.Encrypt：加密payload
jwe.Decrypt：解密payload
下面看下如何生成JWT，以及如何结合使用JWE和JWK对其进行加密。
下面jwt使用对称方式进行签名/解析，jwe使用非对称方式进行加解密
package main
import (
"crypto/rand"
"crypto/rsa"
"fmt"
"github.com/lestrrat-go/jwx/v2/jwa"
"github.com/lestrrat-go/jwx/v2/jwe"
"github.com/lestrrat-go/jwx/v2/jwk"
"github.com/lestrrat-go/jwx/v2/jws"
"github.com/lestrrat-go/jwx/v2/jwt"
"time"
)
func main() {
// 创建一个jwt token结构体
tok, err := jwt.NewBuilder().
Issuer(`github.com/lestrrat-go/jwx`).
IssuedAt(time.Now()).
Build()
if err != nil {
fmt.Printf("failed to build token: %s\n", err)
return
}
//创建对称签名的key
key, err := jwk.FromRaw([]byte(`abracadabra`))
if err != nil {
fmt.Printf(`failed to create new symmetric key: %s`, err)
return
}
key.Set(jws.KeyIDKey, `secret-key`)
//使用HS256对称签名方式进行签名，生成JWS
signed, err := jwt.Sign(tok, jwt.WithKey(jwa.HS256, key))
//下面使用jwe对JWS进行加密，使用的是非对称加密方式
//首先生成RSA密钥对
rawprivkey, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
fmt.Printf("failed to create raw private key: %s\n", err)
return
}
//提取私钥，用于解密
privkey, err := jwk.FromRaw(rawprivkey)
if err != nil {
fmt.Printf("failed to create private key: %s\n", err)
return
}
//提取公钥，用于加密
pubkey, err := privkey.PublicKey()
if err != nil {
fmt.Printf("failed to create public key:%s\n", err)
return
}
//使用公钥加密JWS
encrypted, err := jwe.Encrypt(signed, jwe.WithKey(jwa.RSA_OAEP, pubkey))
if err != nil {
fmt.Printf("failed to encrypt payload: %s\n", err)
return
}
//使用私钥解密出JWS
decrypted, err := jwe.Decrypt(encrypted, jwe.WithKey(jwa.RSA_OAEP, privkey))
if err != nil {
fmt.Printf("failed to decrypt payload: %s\n", err)
return
}
//使用对称签名方式解析出token 结构体
parsedTok, err := jwt.Parse(decrypted, jwt.WithKey(jwa.HS256, key), jwt.WithValidate(true))
if err != nil {
fmt.Println("failed to parse signed token")
return
}
fmt.Println(parsedTok)
}
下面使用非对称方式进行签名/解析：
package main
import (
"crypto/rand"
"crypto/rsa"
"fmt"
"github.com/lestrrat-go/jwx/v2/jwa"
"github.com/lestrrat-go/jwx/v2/jwt"
)
func main() {
//创建RSA密钥对
privKey, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
fmt.Printf("failed to generate private key: %s\n", err)
return
}
var payload []byte
{ // 创建JWT payload
token := jwt.New()
token.Set(`foo`, `bar`)
//使用RSA私钥进行签名
payload, err = jwt.Sign(token, jwt.WithKey(jwa.RS256, privKey))
if err != nil {
fmt.Printf("failed to generate signed payload: %s\n", err)
return
}
}
{ // 使用RSA公钥进行解析
token, err := jwt.Parse(
payload,
jwt.WithValidate(true),
jwt.WithKey(jwa.RS256, &privKey.PublicKey),
)
if err != nil {
fmt.Printf("failed to parse JWT token: %s\n", err)
return
}
fmt.Println(token)
}
}
上面使用的JWK是使用代码生成的，也可以加载本地文件(jwk.ReadFile)或通过JSU的方式从网络上拉取所需的JWK(jwk.Fetch)。
lestrrat-go的官方文档中给出了很多指导。
{
v, err := jwk.ReadFile(`private-key.pem`, jwk.WithPEM(true))
if err != nil {
// handle error
}
}
{
v, err := jwk.ReadFile(`public-key.pem`, jwk.WithPEM(true))
if err != nil {
// handle error
}
}
srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
fmt.Fprintf(w, `{
"keys": [
{"kty":"EC",
"crv":"P-256",
"x":"MKBCTNIcKUSDii11ySs3526iDZ8AiTo7Tu6KPAqv7D4",
"y":"4Etl6SRW2YiLUrN5vfvVHuhp7x8PxltmWWlbbM4IFyM",
"use":"enc",
"kid":"1"},
{"kty":"RSA",
"n": "0vx7agoebGcQSuuPiLJXZptN9nndrQmbXEps2aiAFbWhM78LhWx4cbbfAAtVT86zwu1RK7aPFFxuhDR1L6tSoc_BJECPebWKRXjBZCiFV4n3oknjhMstn64tZ_2W-5JsGY4Hc5n9yBXArwl93lqt7_RN5w6Cf0h4QyQ5v-65YGjQR0_FDW2QvzqY368QQMicAtaSqzs8KJZgnYb9c7d0zgdAZHzu6qMQvRL5hajrn1n91CbOpbISD08qNLyrdkt-bFTWhAI4vMQFh6WeZu0fM4lFd2NcRwr3XPksINHaQ-G_xBniIqbw0Ls1jF44-csFCur-kEgU8awapJzKnqDKgw",
"e":"AQAB",
"alg":"RS256",
"kid":"2011-04-29"}
]
}`)
}))
defer srv.Close()
set, err := jwk.Fetch(
context.Background(),
srv.URL,
// This is necessary because httptest.Server is using a custom certificate
jwk.WithHTTPClient(srv.Client()),
)
if err != nil {
fmt.Printf("failed to fetch JWKS: %s\n", err)
return
}