> 科技资讯 > golang使用JWX进行认证和加密

golang使用JWX进行认证和加密

科技资讯 投稿 12200℃ 0 评论

golang使用JWX进行认证和加密

golang使用JWX进行认证和加密

下面描述来自golang-jwt的官方描述：

概述

Bearer token，JWT包括三个用.分割的部分：前两部分为使用base64url编码的JSON对象，最后一部分是签名。第一部分称为header，包含用于验证最后一部分签名所需的信息，如使用的签名方式和使用的密钥等，中间的部分是程序最关心的部分，称为Claim，RFC 7519定义了相关的字段，当然也可以添加自己的字段。

签名 vs 加密

    token的创建者拥有签名的secret
  • 数据一旦被签名就不能修改

需要注意的是，JWT并不支持加密，因此任何人都能读取token 的内容。如果需要加密数据，可以使用配套的规范--JWE，可以参考这两个库：lestrrat-go/jwx和golang-jwt/jwe。

选择签名方法

对称签名方法，如HSA，只需要一个secret即可，这也是最简单的签名方法，可以使用任何[]byte作为有效的secret。对称加密的计算速度也相对快一些。当token的生产者和消费者都可信的前提下，可以考虑使用对称加密。由于对称加密使用相同的secret进行token的签名和验证，因此不能轻易将密钥分发出去。

JWT和OAuth

这里提一下，OAuth和JWT并不是一回事，一个JWT token只是一个简单的被签名的JSON对象，可以用在所需要的地方，最常见的方式是用在OAuth2认证中。

    OAuth是一种允许身份提供者与用户登录的服务分离的协议。例如，你可以使用Facebook登陆不同的服务(Yelp、Spotify等，此时用的就是OAuth。
  • OAuth定义了几种传递身份验证数据的选项，其中流行的一种方式称为"bearer token"，一个bearer token就是一个只能被已认证的用户持有的简单字符串，即通过提供该token来进行身份认证。从这里可以看出JWT可以作为一种bearer token。
  • 由于bearer token用于认证，因此私密性很重要，这也是为什么通常会通过SSL来使用bearer token。

JWT的用法

从上面的官方描述中可以看到JWT其实就是一个字符串，其分为三段：header，主要指定签名方法；claim，用于提供用户身份数据；signature，使用header中指定的签名方法进行签名，签名时主要使用了三个基础数据：

  1. JWT的过期时间：JWT有一个过期时间。在用户登陆服务器之后，服务器会给客户端返回JWT，当客户端服务服务端时会将JWT传递给服务端，服务端除了需要验证客户端的签名之外还需要验证该token是否过期，JWT的过期时间数据位于claims中。

  2. 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进行加密。

    JWS(SignedJWT：经过签名的jwt，为三段式结构：header、claims、signature

  • alg字段值。

  • 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
    

    • 



Example 1


下面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
}



Example 2


下面使用非对称方式进行签名/解析：


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
	}
}



Example 3


上面使用的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
	}



参考


    JWT、JWE、JWS 、JWK 到底是什么？该用 JWT 还是 JWS？

            
            

                编程笔记
                »
                golang使用JWX进行认证和加密
            

            

                
                    赞同 (63)
                
                or
                
                    
                    分享 (0)
游客 发表我的评论   换个身份
取消评论

表情
(0)个小伙伴在吐槽