jwt-go

Ago (or 'golang' for search engine friendliness) implementation ofJSON Web Tokens.

IMPORT PATH CHANGE: Starting fromv3.2.1, the import path has changed fromgithub.com/dgrijalva/jwt-go togithub.com/golang-jwt/jwt. After the original author of the library suggested migrating the maintenance ofjwt-go, a dedicated team of open source maintainers decided to clone the existing library into this repository. Seedgrijalva/jwt-go#462 for a detailed discussion on this topic.

Future releases will be using thegithub.com/golang-jwt/jwt import path and continue the existing versioning scheme ofv3.x.x+incompatible. Backwards-compatible patches and fixes will be done on thev3 release branch, where as new build-breaking features will be developed in av4 release, possibly including a SIV-style import path.

SECURITY NOTICE: Some older versions of Go have a security issue in the crypto/elliptic. Recommendation is to upgrade to at least 1.15 See issuedgrijalva/jwt-go#216 for more detail.

SECURITY NOTICE: It's important that youvalidate thealg presented is what you expect. This library attempts to make it easy to do the right thing by requiring key types match the expected alg, but you should take the extra step to verify it in your usage. See the examples provided.

Supported Go versions

Our support of Go versions is aligned with Go'sversion release policy.So we will support a major version of Go until there are two newer major releases.We no longer support building jwt-go with unsupported Go versions, as these contain security vulnerabilitieswhich will not be fixed.

What the heck is a JWT?

JWT.io hasa great introduction to JSON Web Tokens.

In short, it's a signed JSON object that does something useful (for example, authentication). It's commonly used forBearer tokens in Oauth 2. A token is made of three parts, separated by.'s. The first two parts are JSON objects, that have beenbase64url encoded. The last part is the signature, encoded the same way.

The first part is called the header. It contains the necessary information for verifying the last part, the signature. For example, which encryption method was used for signing and what key was used.

The part in the middle is the interesting bit. It's called the Claims and contains the actual stuff you care about. Refer toRFC 7519 for information about reserved keys and the proper way to add your own.

What's in the box?

This library supports the parsing and verification as well as the generation and signing of JWTs. Current supported signing algorithms are HMAC SHA, RSA, RSA-PSS, and ECDSA, though hooks are present for adding your own.

Examples

Seethe project documentation for examples of usage:

• Simple example of parsing and validating a token
• Simple example of building and signing a token
• Directory of Examples

Extensions

This library publishes all the necessary components for adding your own signing methods. Simply implement theSigningMethod interface and register a factory method usingRegisterSigningMethod.

Here's an example of an extension that integrates with multiple Google Cloud Platform signing tools (AppEngine, IAM API, Cloud KMS):https://github.com/someone1/gcp-jwt-go

Compliance

This library was last reviewed to comply withRTF 7519 dated May 2015 with a few notable differences:

• In order to protect against accidental use ofUnsecured JWTs, tokens usingalg=none will only be accepted if the constantjwt.UnsafeAllowNoneSignatureType is provided as the key.

Project Status & Versioning

This library is considered production ready. Feedback and feature requests are appreciated. The API should be considered stable. There should be very few backwards-incompatible changes outside of major version updates (and only with good reason).

This project usesSemantic Versioning 2.0.0. Accepted pull requests will land onmain. Periodically, versions will be tagged frommain. You can find all the releases onthe project releases page.

While we try to make it obvious when we make breaking changes, there isn't a great mechanism for pushing announcements out to users. You may want to use this alternative package include:gopkg.in/golang-jwt/jwt.v3. It will do the right thing WRT semantic versioning.

BREAKING CHANGES:*

• Version 3.0.0 includesa lot of changes from the 2.x line, including a few that break the API. We've tried to break as few things as possible, so there should just be a few type signature changes. A full list of breaking changes is available inVERSION_HISTORY.md. SeeMIGRATION_GUIDE.md for more information on updating your code.

Usage Tips

Signing vs Encryption

A token is simply a JSON object that is signed by its author. this tells you exactly two things about the data:

• The author of the token was in the possession of the signing secret
• The data has not been modified since it was signed

It's important to know that JWT does not provide encryption, which means anyone who has access to the token can read its contents. If you need to protect (encrypt) the data, there is a companion spec,JWE, that provides this functionality. JWE is currently outside the scope of this library.

Choosing a Signing Method

There are several signing methods available, and you should probably take the time to learn about the various options before choosing one. The principal design decision is most likely going to be symmetric vs asymmetric.

Symmetric signing methods, such as HSA, use only a single secret. This is probably the simplest signing method to use since any[]byte can be used as a valid secret. They are also slightly computationally faster to use, though this rarely is enough to matter. Symmetric signing methods work the best when both producers and consumers of tokens are trusted, or even the same system. Since the same secret is used to both sign and validate tokens, you can't easily distribute the key for validation.

Asymmetric signing methods, such as RSA, use different keys for signing and verifying tokens. This makes it possible to produce tokens with a private key, and allow any consumer to access the public key for verification.

Signing Methods and Key Types

Each signing method expects a different object type for its signing keys. See the package documentation for details. Here are the most common ones:

• TheHMAC signing method (HS256,HS384,HS512) expect[]byte values for signing and validation
• TheRSA signing method (RS256,RS384,RS512) expect*rsa.PrivateKey for signing and*rsa.PublicKey for validation
• TheECDSA signing method (ES256,ES384,ES512) expect*ecdsa.PrivateKey for signing and*ecdsa.PublicKey for validation

JWT and OAuth

It's worth mentioning that OAuth and JWT are not the same thing. A JWT token is simply a signed JSON object. It can be used anywhere such a thing is useful. There is some confusion, though, as JWT is the most common type of bearer token used in OAuth2 authentication.

Without going too far down the rabbit hole, here's a description of the interaction of these technologies:

• OAuth is a protocol for allowing an identity provider to be separate from the service a user is logging in to. For example, whenever you use Facebook to log into a different service (Yelp, Spotify, etc), you are using OAuth.
• OAuth defines several options for passing around authentication data. One popular method is called a "bearer token". A bearer token is simply a string thatshould only be held by an authenticated user. Thus, simply presenting this token proves your identity. You can probably derive from here why a JWT might make a good bearer token.
• Because bearer tokens are used for authentication, it's important they're kept secret. This is why transactions that use bearer tokens typically happen over SSL.

Troubleshooting

This library uses descriptive error messages whenever possible. If you are not getting the expected result, have a look at the errors. The most common place people get stuck is providing the correct type of key to the parser. See the above section on signing methods and key types.

More

Documentation can be foundon pkg.go.dev.

The command line utility included in this project (cmd/jwt) provides a straightforward example of token creation and parsing as well as a useful tool for debugging your own integration. You'll also find several implementation examples in the documentation.

package mainimport ("bytes""crypto/rsa""fmt""io""log""net/http""net/url""strings""github.com/golang-jwt/jwt")var (verifyKey *rsa.PublicKeyserverPort int)func fatal(err error) {if err != nil {log.Fatal(err)}}// Define some custom types were going to use within our tokenstype CustomerInfo struct {Name stringKind string}type CustomClaimsExample struct {*jwt.StandardClaimsTokenType stringCustomerInfo}func main() {// See func authHandler for an example auth handler that produces a tokenres, err := http.PostForm(fmt.Sprintf("http://localhost:%v/authenticate", serverPort), url.Values{"user": {"test"},"pass": {"known"},})if err != nil {fatal(err)}if res.StatusCode != 200 {fmt.Println("Unexpected status code", res.StatusCode)}// Read the token out of the response bodybuf := new(bytes.Buffer)io.Copy(buf, res.Body)res.Body.Close()tokenString := strings.TrimSpace(buf.String())// Parse the tokentoken, err := jwt.ParseWithClaims(tokenString, &CustomClaimsExample{}, func(token *jwt.Token) (interface{}, error) {// since we only use the one private key to sign the tokens,// we also only use its public counter part to verifyreturn verifyKey, nil})fatal(err)claims := token.Claims.(*CustomClaimsExample)fmt.Println(claims.CustomerInfo.Name)}

Output:test

package mainimport ("bytes""crypto/rsa""fmt""io""log""net/http""time""github.com/golang-jwt/jwt")var (signKey    *rsa.PrivateKeyserverPort int)func fatal(err error) {if err != nil {log.Fatal(err)}}// Define some custom types were going to use within our tokenstype CustomerInfo struct {Name stringKind string}type CustomClaimsExample struct {*jwt.StandardClaimsTokenType stringCustomerInfo}func main() {// Make a sample token// In a real world situation, this token will have been acquired from// some other API call (see Example_getTokenViaHTTP)token, err := createToken("foo")fatal(err)// Make request.  See func restrictedHandler for example request processorreq, err := http.NewRequest("GET", fmt.Sprintf("http://localhost:%v/restricted", serverPort), nil)fatal(err)req.Header.Set("Authorization", fmt.Sprintf("Bearer %v", token))res, err := http.DefaultClient.Do(req)fatal(err)// Read the response bodybuf := new(bytes.Buffer)io.Copy(buf, res.Body)res.Body.Close()fmt.Println(buf.String())}func createToken(user string) (string, error) {t := jwt.New(jwt.GetSigningMethod("RS256"))t.Claims = &CustomClaimsExample{&jwt.StandardClaims{ExpiresAt: time.Now().Add(time.Minute * 1).Unix(),},"level1",CustomerInfo{user, "human"},}return t.SignedString(signKey)}

Output:Welcome, foo

Constants¶

const (ValidationErrorMalformeduint32 = 1 <<iota// Token is malformedValidationErrorUnverifiable// Token could not be verified because of signing problemsValidationErrorSignatureInvalid// Signature validation failed// Standard Claim validation errorsValidationErrorAudience// AUD validation failedValidationErrorExpired// EXP validation failedValidationErrorIssuedAt// IAT validation failedValidationErrorIssuer// ISS validation failedValidationErrorNotValidYet// NBF validation failedValidationErrorId// JTI validation failedValidationErrorClaimsInvalid// Generic claims validation error)

const UnsafeAllowNoneSignatureType unsafeNoneMagicConstant = "none signing method allowed"

Variables¶

var (ErrNotECPublicKey  =errors.New("Key is not a valid ECDSA public key")ErrNotECPrivateKey =errors.New("Key is not a valid ECDSA private key"))

var (ErrNotEdPrivateKey =errors.New("Key is not a valid Ed25519 private key")ErrNotEdPublicKey  =errors.New("Key is not a valid Ed25519 public key"))

var (ErrInvalidKey      =errors.New("key is invalid")ErrInvalidKeyType  =errors.New("key is of invalid type")ErrHashUnavailable =errors.New("the requested hash function is unavailable"))

var (ErrKeyMustBePEMEncoded =errors.New("Invalid Key: Key must be a PEM encoded PKCS1 or PKCS8 key")ErrNotRSAPrivateKey    =errors.New("Key is not a valid RSA private key")ErrNotRSAPublicKey     =errors.New("Key is not a valid RSA public key"))

var (// Sadly this is missing from crypto/ecdsa compared to crypto/rsaErrECDSAVerification =errors.New("crypto/ecdsa: verification error"))

var (ErrEd25519Verification =errors.New("ed25519: verification error"))

var NoneSignatureTypeDisallowedErrorerror

var SigningMethodNone *signingMethodNone

var TimeFunc =time.Now

Functions¶

func DecodeSegment(segstring) ([]byte,error)

func EncodeSegment(seg []byte)string

func ParseECPrivateKeyFromPEM(key []byte) (*ecdsa.PrivateKey,error)

func ParseECPublicKeyFromPEM(key []byte) (*ecdsa.PublicKey,error)

func ParseEdPrivateKeyFromPEM(key []byte) (crypto.PrivateKey,error)

func ParseEdPublicKeyFromPEM(key []byte) (crypto.PublicKey,error)

func ParseRSAPrivateKeyFromPEM(key []byte) (*rsa.PrivateKey,error)

func ParseRSAPrivateKeyFromPEMWithPassword(key []byte, passwordstring) (*rsa.PrivateKey,error)

func ParseRSAPublicKeyFromPEM(key []byte) (*rsa.PublicKey,error)

func RegisterSigningMethod(algstring, f func()SigningMethod)

Types¶

type Claims interface {Valid()error}

type Keyfunc func(*Token) (interface{},error)

type MapClaims map[string]interface{}

func (mMapClaims) Valid()error

func (mMapClaims) VerifyAudience(cmpstring, reqbool)bool

func (mMapClaims) VerifyExpiresAt(cmpint64, reqbool)bool

func (mMapClaims) VerifyIssuedAt(cmpint64, reqbool)bool

func (mMapClaims) VerifyIssuer(cmpstring, reqbool)bool

func (mMapClaims) VerifyNotBefore(cmpint64, reqbool)bool

type Parser struct {ValidMethods         []string// If populated, only these methods will be considered validUseJSONNumberbool// Use JSON Number format in JSON decoderSkipClaimsValidationbool// Skip claims validation during token parsing}

func (p *Parser) Parse(tokenStringstring, keyFuncKeyfunc) (*Token,error)

func (p *Parser) ParseUnverified(tokenStringstring, claimsClaims) (token *Token, parts []string, errerror)

func (p *Parser) ParseWithClaims(tokenStringstring, claimsClaims, keyFuncKeyfunc) (*Token,error)

type SigningMethod interface {Verify(signingString, signaturestring, key interface{})error// Returns nil if signature is validSign(signingStringstring, key interface{}) (string,error)// Returns encoded signature or errorAlg()string// returns the alg identifier for this method (example: 'HS256')}

func GetSigningMethod(algstring) (methodSigningMethod)

type SigningMethodECDSA struct {NamestringHashcrypto.HashKeySizeintCurveBitsint}

var (SigningMethodES256 *SigningMethodECDSASigningMethodES384 *SigningMethodECDSASigningMethodES512 *SigningMethodECDSA)

func (m *SigningMethodECDSA) Alg()string

func (m *SigningMethodECDSA) Sign(signingStringstring, key interface{}) (string,error)

func (m *SigningMethodECDSA) Verify(signingString, signaturestring, key interface{})error

type SigningMethodEd25519 struct{}

var (SigningMethodEdDSA *SigningMethodEd25519)

func (m *SigningMethodEd25519) Alg()string

func (m *SigningMethodEd25519) Sign(signingStringstring, key interface{}) (string,error)

func (m *SigningMethodEd25519) Verify(signingString, signaturestring, key interface{})error

type SigningMethodHMAC struct {NamestringHashcrypto.Hash}

var (SigningMethodHS256  *SigningMethodHMACSigningMethodHS384  *SigningMethodHMACSigningMethodHS512  *SigningMethodHMACErrSignatureInvalid =errors.New("signature is invalid"))

func (m *SigningMethodHMAC) Alg()string

func (m *SigningMethodHMAC) Sign(signingStringstring, key interface{}) (string,error)

func (m *SigningMethodHMAC) Verify(signingString, signaturestring, key interface{})error

type SigningMethodRSA struct {NamestringHashcrypto.Hash}

var (SigningMethodRS256 *SigningMethodRSASigningMethodRS384 *SigningMethodRSASigningMethodRS512 *SigningMethodRSA)

func (m *SigningMethodRSA) Alg()string

func (m *SigningMethodRSA) Sign(signingStringstring, key interface{}) (string,error)

func (m *SigningMethodRSA) Verify(signingString, signaturestring, key interface{})error

type SigningMethodRSAPSS struct {*SigningMethodRSAOptions *rsa.PSSOptions// VerifyOptions is optional. If set overrides Options for rsa.VerifyPPS.// Used to accept tokens signed with rsa.PSSSaltLengthAuto, what doesn't follow//https://tools.ietf.org/html/rfc7518#section-3.5 but was used previously.// Seehttps://github.com/dgrijalva/jwt-go/issues/285#issuecomment-437451244 for details.VerifyOptions *rsa.PSSOptions}

var (SigningMethodPS256 *SigningMethodRSAPSSSigningMethodPS384 *SigningMethodRSAPSSSigningMethodPS512 *SigningMethodRSAPSS)

func (m *SigningMethodRSAPSS) Sign(signingStringstring, key interface{}) (string,error)

func (m *SigningMethodRSAPSS) Verify(signingString, signaturestring, key interface{})error

type StandardClaims struct {Audiencestring `json:"aud,omitempty"`ExpiresAtint64  `json:"exp,omitempty"`Idstring `json:"jti,omitempty"`IssuedAtint64  `json:"iat,omitempty"`Issuerstring `json:"iss,omitempty"`NotBeforeint64  `json:"nbf,omitempty"`Subjectstring `json:"sub,omitempty"`}

func (cStandardClaims) Valid()error

func (c *StandardClaims) VerifyAudience(cmpstring, reqbool)bool

func (c *StandardClaims) VerifyExpiresAt(cmpint64, reqbool)bool

func (c *StandardClaims) VerifyIssuedAt(cmpint64, reqbool)bool

func (c *StandardClaims) VerifyIssuer(cmpstring, reqbool)bool

func (c *StandardClaims) VerifyNotBefore(cmpint64, reqbool)bool

type Token struct {Rawstring// The raw token.  Populated when you Parse a tokenMethodSigningMethod// The signing method used or to be usedHeader    map[string]interface{}// The first segment of the tokenClaimsClaims// The second segment of the tokenSignaturestring// The third segment of the token.  Populated when you Parse a tokenValidbool// Is the token valid?  Populated when you Parse/Verify a token}

func New(methodSigningMethod) *Token

package mainimport ("fmt""time""github.com/golang-jwt/jwt")// For HMAC signing method, the key can be any []byte. It is recommended to generate// a key using crypto/rand or something equivalent. You need the same key for signing// and validating.var hmacSampleSecret []bytefunc main() {// Create a new token object, specifying signing method and the claims// you would like it to contain.token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{"foo": "bar","nbf": time.Date(2015, 10, 10, 12, 0, 0, 0, time.UTC).Unix(),})// Sign and get the complete encoded token as a string using the secrettokenString, err := token.SignedString(hmacSampleSecret)fmt.Println(tokenString, err)}

Output:eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJmb28iOiJiYXIiLCJuYmYiOjE0NDQ0Nzg0MDB9.u1riaD1rW97opCoAuRCTy4w58Br-Zk-bh7vLiRIsrpU <nil>

func NewWithClaims(methodSigningMethod, claimsClaims) *Token

package mainimport ("fmt""github.com/golang-jwt/jwt")func main() {mySigningKey := []byte("AllYourBase")type MyCustomClaims struct {Foo string `json:"foo"`jwt.StandardClaims}// Create the Claimsclaims := MyCustomClaims{"bar",jwt.StandardClaims{ExpiresAt: 15000,Issuer:    "test",},}token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)ss, err := token.SignedString(mySigningKey)fmt.Printf("%v %v", ss, err)}

Output:eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJmb28iOiJiYXIiLCJleHAiOjE1MDAwLCJpc3MiOiJ0ZXN0In0.HE7fK0xOQwFEr4WDgRWj4teRPZ6i3GLwD5YCm6Pwu_c <nil>

package mainimport ("fmt""github.com/golang-jwt/jwt")func main() {mySigningKey := []byte("AllYourBase")// Create the Claimsclaims := &jwt.StandardClaims{ExpiresAt: 15000,Issuer:    "test",}token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)ss, err := token.SignedString(mySigningKey)fmt.Printf("%v %v", ss, err)}

Output:eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1MDAwLCJpc3MiOiJ0ZXN0In0.QsODzZu3lUZMVdhbO76u3Jv02iYCvEHcYVUI1kOWEU0 <nil>

func Parse(tokenStringstring, keyFuncKeyfunc) (*Token,error)

package mainimport ("fmt""github.com/golang-jwt/jwt")func main() {// Token from another example.  This token is expiredvar tokenString = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJmb28iOiJiYXIiLCJleHAiOjE1MDAwLCJpc3MiOiJ0ZXN0In0.HE7fK0xOQwFEr4WDgRWj4teRPZ6i3GLwD5YCm6Pwu_c"token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {return []byte("AllYourBase"), nil})if token.Valid {fmt.Println("You look nice today")} else if ve, ok := err.(*jwt.ValidationError); ok {if ve.Errors&jwt.ValidationErrorMalformed != 0 {fmt.Println("That's not even a token")} else if ve.Errors&(jwt.ValidationErrorExpired|jwt.ValidationErrorNotValidYet) != 0 {// Token is either expired or not active yetfmt.Println("Timing is everything")} else {fmt.Println("Couldn't handle this token:", err)}} else {fmt.Println("Couldn't handle this token:", err)}}

Output:Timing is everything

package mainimport ("fmt""github.com/golang-jwt/jwt")// For HMAC signing method, the key can be any []byte. It is recommended to generate// a key using crypto/rand or something equivalent. You need the same key for signing// and validating.var hmacSampleSecret []bytefunc main() {// sample token string taken from the New exampletokenString := "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJmb28iOiJiYXIiLCJuYmYiOjE0NDQ0Nzg0MDB9.u1riaD1rW97opCoAuRCTy4w58Br-Zk-bh7vLiRIsrpU"// Parse takes the token string and a function for looking up the key. The latter is especially// useful if you use multiple keys for your application.  The standard is to use 'kid' in the// head of the token to identify which key to use, but the parsed token (head and claims) is provided// to the callback, providing flexibility.token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {// Don't forget to validate the alg is what you expect:if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])}// hmacSampleSecret is a []byte containing your secret, e.g. []byte("my_secret_key")return hmacSampleSecret, nil})if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {fmt.Println(claims["foo"], claims["nbf"])} else {fmt.Println(err)}}

Output:bar 1.4444784e+09

func ParseWithClaims(tokenStringstring, claimsClaims, keyFuncKeyfunc) (*Token,error)

package mainimport ("fmt""time""github.com/golang-jwt/jwt")func main() {tokenString := "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJmb28iOiJiYXIiLCJleHAiOjE1MDAwLCJpc3MiOiJ0ZXN0In0.HE7fK0xOQwFEr4WDgRWj4teRPZ6i3GLwD5YCm6Pwu_c"type MyCustomClaims struct {Foo string `json:"foo"`jwt.StandardClaims}// sample token is expired.  override time so it parses as validat(time.Unix(0, 0), func() {token, err := jwt.ParseWithClaims(tokenString, &MyCustomClaims{}, func(token *jwt.Token) (interface{}, error) {return []byte("AllYourBase"), nil})if claims, ok := token.Claims.(*MyCustomClaims); ok && token.Valid {fmt.Printf("%v %v", claims.Foo, claims.StandardClaims.ExpiresAt)} else {fmt.Println(err)}})}// Override time value for tests.  Restore default value after.func at(t time.Time, f func()) {jwt.TimeFunc = func() time.Time {return t}f()jwt.TimeFunc = time.Now}

Output:bar 15000

func (t *Token) SignedString(key interface{}) (string,error)

func (t *Token) SigningString() (string,error)

type ValidationError struct {Innererror// stores the error returned by external dependencies, i.e.: KeyFuncErrorsuint32// bitfield.  see ValidationError... constants// contains filtered or unexported fields}

func NewValidationError(errorTextstring, errorFlagsuint32) *ValidationError

func (eValidationError) Error()string