AWS KMS signature returns Invalid Signature for my JWT

Question

I am trying to generate a simple JWT, using ES256 using KMS. Everything looks fine to the naked eye. But I get "Invalid signature" when I test it through jwt.io. The code is quite simple:

public async Task<string> GenerateJwt(object payload)
{
    var encodedHeader = Base64Encoder.EncodeBase64Url(JsonSerializer.Serialize(_header));
    var encodedPayload = Base64Encoder.EncodeBase64Url(JsonSerializer.Serialize(payload));

    var signatureData = Encoding.ASCII.GetBytes(encodedHeader + "." + encodedPayload);

    var signature = await _signingService.Sign(signatureData);
    var encodedSignature = Base64Encoder.ReplaceSpecialUrlCharacters(Convert.ToBase64String(signature));

    return encodedHeader + "." + encodedPayload + "." + encodedSignature;
}

The SigningService looks something like this:

public async Task<byte[]> Sign(byte[] signatureData)
{
    using var memoryStream = new MemoryStream(signatureData, 0, signatureData.Length);
    var signRequest = new SignRequest()
    {
        KeyId = _signingKeyId,
        Message = memoryStream,
        SigningAlgorithm = SigningAlgorithmSpec.ECDSA_SHA_256
    };
    SignResponse signResponse = await _keyManagementService.SignAsync(signRequest);
    return signResponse.Signature.ToArray();
}

_keyManagementService is an IAmazonKeyManagementService from AWSSDK.KeyManagementService 3.5.2.6

In KMS the key is set up like this:

Key Spec: ECC_NIST_P256
Key Usage: Sign and verify
Signing algorithms: ECDSA_SHA_256

Public key in KMS (using localstack)

MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEj7Cy/Gbx3jnuPdanuBSjuUmdnr7tQ/BcOytDlFoHWdNA1scc6RwNwqnNbmRE0BmwnlFNDVGxWU5oycTig8p0KQ==

Example on generated output

eyJhbGciOiJFUzI1NiJ9.eyJ0ZXN0MSI6MSwidGVzdDIiOiJ0d28iLCJ0ZXN0MyI6ZmFsc2V9.MEYCIQCiatnRhYGBKgdJj9LECe7mJ4bhhkVTvFSgpVI3Dm14pwIhAOrHAu0vqKvVwdgpAhaU7KOhiIBZdcEOuzfXrdXldCFQ

If it sign it with the built in tools (by just replacing the signatureData row above) with the same input I get it to validate in jwt.io.

var ecdsa = ECDsa.Create();
ecdsa.GenerateKey(ECCurve.NamedCurves.nistP256);
var signatureData = ecdsa.SignData(signatureData, HashAlgorithmName.SHA256);

Any input would be welcome as it feels like I've tested everything...

What do you put into jwt.io as the public key to verify against? If I remember correctly it is a pain because jwt.io expects the key to e.g. have a header and footer: `-----BEGIN PUBLIC KEY-----` and `-----END PUBLIC KEY-----`... — luk2302, Feb 12 '21 at 10:32
In KMS there is a tab for Public key which contains the header and footer. So whenever i've tried I've made sure that those are there. — Mikael Gidmark, Feb 12 '21 at 10:42
you could post that public key and one of the tokens signed with that key here so that we can verify it. By the way: you should use a library to create and unpack jwt tokens, libraries that properly take care of `iat` and `exp` for example, and `iss`... — luk2302, Feb 12 '21 at 10:47

score 5 · Accepted Answer · edited Oct 07 '21 at 08:57

The problem was that KMS returns the signature in another format:

DER-encoded object as defined by ANS X9.62–2005

While the JWT should in the format R || S according to https://www.rfc-editor.org/rfc/rfc7515#appendix-A.3.1

So what I did as to add a convert method using BouncyCastle and called that before converting it to base64url:

private byte[] ConvertSignature(byte[] signature)
{
    var asn1 = Asn1Object.FromByteArray(signature) as DerSequence;
    if (asn1 == null)
        return Array.Empty<byte>();

    if (asn1.Count < 2)
        return Array.Empty<byte>();

    var r = asn1[0] as DerInteger;
    var s = asn1[1] as DerInteger;

    if (r == null || s == null)
        return Array.Empty<byte>();

    return Array.Empty<byte>()
        .Concat(r.Value.ToByteArrayUnsigned())
        .Concat(s.Value.ToByteArrayUnsigned())
        .ToArray();
}

AWS KMS signature returns Invalid Signature for my JWT

1 Answers1