How to get header values from jwt

[Edwin-Luijten]

Scenario:
I'm getting a third party jwt token which is signed and has the following headers:

{
  "typ": "JWT",
  "kid": "{{ uuid like string}}",
  "alg": "ES256",
  "iss": "{{ redacted }}",
  "client": "{{ redacted }}",
  "signer": "{{ redacted }}",
  "exp": 1641996395
}

The endpoint for the public key has this format: `https://domain.com/{{ kid }}.

When looking trough the code I would think the method KeySetProvider in combination with Fetch would be the way to go, but in order to use those I need a way to retrieve values from the headers eg: token.Header.Get("kid").

The way I went with it now is by getting the encoded header part, base64 decode in and then unmarshal it.
Now I can retrieve the key by doing a http request and transform it into a Set.

func getPublicKey(kid string) (jwk.Key, error) {
	res, err := http.Get(fmt.Sprintf(op.publicKeyBaseEndpoint, kid))
        defer res.Body.Close()	
        if err != nil {
		return nil, err
	}

	b, err := ioutil.ReadAll(res.Body)
	if err != nil {
		return nil, err
	}

	k, err := jwk.ParseKey(b, jwk.WithPEM(true))
	if err != nil {
		return nil, fmt.Errorf("error jwk parse-key: %w", err)
	}

	k.Set(jwk.KeyIDKey, kid)
	k.Set(jwk.AlgorithmKey, jwa.ES256)

	return k, nil
}

Then I use that key like this:

token, err := jwt.ParseHeader(header, op.header, jwt.WithValidate(true), jwt.WithVerify(jwa.ES256, key))

This works but I feel I'm not using the correct feature of the library.

[lestrrat]

Please kindly read the disclaimer and use the appropriate medium for open-ended questions. We would like to use GitHub Issues for technical issues, not discussions on usage. For the time being I'm converting this to a discussion thread.

---

You show very little information, so the following is a guess.

I'm assuming from your text that you have a JWS-signed JWT, which you would like to verify using a key, whose location is written in the kid field?

Assuming this is the case, some random observations:

• JWTs do not have a kid field (it could, but it's not part of the standard headers). kid is used by JWS, JWK, and JWE.
• There is a field called jku in JWS/JWE (which can be accessed by their JWKSetURL methods) that is used to pass the URL of the JWK. Are you sure you want to use kid for the url?
• If jku and kid are available, you could use jws.VerifyAuto() (which can be called from jwt.Parse() by passing jwt.WithVerifyAuto(true) option. See more docs here and here

If you really need to get at the JWS headers manually from a JWS-signed JWT, perhaps it is jws.Parse() that you are looking for, followed by accessing the public/protected headers of the JWS message, but I cannot tell without you giving us any (pseudo)code.

[Edwin-Luijten]

Thank you for your reply, based on your feedback I expanded my poorly written question with examples.

[lestrrat]

@Edwin-Luijten Okay, this is now based on your second version of the question. Thanks for the rewrite.

I still have some questions in my head, but here's what I would do.
Let me just start at the very beginning. Please note that the following is
pseudocode, and is very untested.

First, in order to retrieve the JWS headers, I would probably just handroll a function to
extract the necessary information (probably kid and alg) instead of using jws.Parse(),
because jws.Parse() would try to do more than you need for your purposes

type tmpJWSHeader struct {
   Algorithm string `json:"alg"`
   KeyID string `json:"kid"`
}

var signed []byte = ....; // the original JWS signed JWT

// Get the first part out of the JWS
i := bytes.Index(signed, []byte('.'))
encodedHdrs = signed[:i]

// decode base64
decodedHdrs := make([]byte, base64.RawURLEncoding.DecodedLen(i))
base64.RawURLEncoding.Decode(decodedHdrs, encodedHdrs)

// unmarshal into struct
var jwsHdr tmpJWSHeader
json.Unmarshal(decodedHdrs, &jwsHdr)

At this point jwsHdr should contain the algorithm and the key ID.

Next, we fetch the JWK using jwk.Fetch(), and the information we got from the JWS headers:

// Fetch the JWK (you can use jwk.AutoRefresh if this URL is repeatedly fetched)
ctx := context.Background() // or whatever
set, _ := jwk.Fetch(ctx, baseURL + jwsHdr.KeyID)

// We're assuming there's only one key in the set
// the key _should_ already have a key ID, but... sure, we'll take your cue
key := set.Get(0)
key.Set(jwk.KeyIDKey, jwsHdr.KeyID)
key.Set(jwk.AlgorithmKey, jwsHdr.Algorithm)

And finally, just use that information to parse the JWT. Originally you wrote about
using jwt.ParseHeader, but since you will have to have the value for the JWS-signed JWT
to get the kid already, I think you can just use that. In this example, it's the signed variable
from above.

token, err := jwt.Parse(signed, jwt.WithValidate(true), jws.WithKeySet(set))

And since you have already set the key ID and algorithm for the key, and the JWS headers also have the same information, you should be able to just shove the JWKS to jwt.Parse() via jws.WithKeySet()

---

I just have to wonder though, why would they make you fetch the JWK using the kid...? why not just populate jku.... and it you wouldn't have to jump through so many hoops. Anyway, hopefully the above sheds some light into how to potentially use this library. Let me know

[iwarapter]

If anyone else finds this - it describes how AWS ALBs can verify that claims are indeed from the ALB - https://docs.aws.amazon.com/elasticloadbalancing/latest/application/listener-authenticate-users.html#user-claims-encoding